adding stats functions

kevloui · kevloui · commit 8d9befa9d189 · 2020-07-31T21:19:36.000+01:00
diff --git a/amadeus-core/src/par_sink/combine.rs b/amadeus-core/src/par_sink/combine.rs
@@ -20,12 +20,13 @@ where
 	F: FnMut<(A, A), Output = A>,
 	Item: Into<Option<A>>,
 {
-	type Done = Option<A>;
+	type State = Option<A>;
+	type Done = Self::State;
 
-	fn zero(&mut self) -> Self::Done {
+	fn zero(&mut self) -> Self::State {
 		None
 	}
-	fn push(&mut self, state: &mut Self::Done, item: Item) {
+	fn push(&mut self, state: &mut Self::State, item: Item) {
 		if let Some(item) = item.into() {
 			*state = Some(if let Some(state) = state.take() {
 				self.0.call_mut((state, item))
@@ -34,6 +35,8 @@ where
 			});
 		}
 	}
+    fn done(&mut self, state: Self::State) -> Self::Done { state }
+
 }
 
 #[derive(new)]
diff --git a/amadeus-core/src/par_sink/combiner.rs b/amadeus-core/src/par_sink/combiner.rs
@@ -57,12 +57,13 @@ where
 	C: CombinerSync<Done = B>,
 	Item: Into<Option<B>>,
 {
-	type Done = Option<B>;
+	type State = Option<B>;
+	type Done = Self::State;
 
-	fn zero(&mut self) -> Self::Done {
+	fn zero(&mut self) -> Self::State {
 		None
 	}
-	fn push(&mut self, state: &mut Self::Done, item: Item) {
+	fn push(&mut self, state: &mut Self::State, item: Item) {
 		if let Some(item) = item.into() {
 			*state = Some(if let Some(state) = state.take() {
 				self.combine(state, item)
@@ -71,4 +72,6 @@ where
 			});
 		}
 	}
+    fn done(&mut self, state: Self::State) -> Self::Done { state }
+
 }
diff --git a/amadeus-core/src/par_sink/count.rs b/amadeus-core/src/par_sink/count.rs
@@ -27,14 +27,18 @@ impl_par_dist! {
 pub struct CountFolder;
 
 impl<Item> FolderSync<Item> for CountFolder {
-	type Done = usize;
+	type State = usize;
+	type Done = Self::State;
 
 	#[inline(always)]
-	fn zero(&mut self) -> Self::Done {
+	fn zero(&mut self) -> Self::State {
 		0
 	}
 	#[inline(always)]
-	fn push(&mut self, state: &mut Self::Done, _item: Item) {
+	fn push(&mut self, state: &mut Self::State, _item: Item) {
 		*state += 1;
 	}
+	#[inline(always)]
+    fn done(&mut self, state: Self::State) -> Self::Done { state }
+
 }
diff --git a/amadeus-core/src/par_sink/fold.rs b/amadeus-core/src/par_sink/fold.rs
@@ -50,28 +50,35 @@ where
 	ID: FnMut<(), Output = B>,
 	F: FnMut<(B, Either<Item, B>), Output = B>,
 {
-	type Done = B;
+	type State = B;
+	type Done = Self::State;
 
-	fn zero(&mut self) -> Self::Done {
+	fn zero(&mut self) -> Self::State {
 		self.identity.call_mut(())
 	}
-	fn push(&mut self, state: &mut Self::Done, item: Item) {
+	fn push(&mut self, state: &mut Self::State, item: Item) {
 		replace_with_or_abort(state, |state| self.op.call_mut((state, Either::Left(item))))
 	}
+    fn done(&mut self, state: Self::State) -> Self::Done { state }
+
 }
 impl<A, ID, F, Item> FolderSync<Item> for FoldFolder<A, ID, F, Item, StepB>
 where
 	ID: FnMut<(), Output = Item>,
 	F: FnMut<(Item, Either<A, Item>), Output = Item>,
 {
-	type Done = Item;
+	type State = Item;
+	type Done = Self::State;
 
-	fn zero(&mut self) -> Self::Done {
+	fn zero(&mut self) -> Self::State {
 		self.identity.call_mut(())
 	}
-	fn push(&mut self, state: &mut Self::Done, item: Item) {
+	fn push(&mut self, state: &mut Self::State, item: Item) {
 		replace_with_or_abort(state, |state| {
 			self.op.call_mut((state, Either::Right(item)))
 		})
 	}
+	#[inline(always)]
+    fn done(&mut self, state: Self::State) -> Self::Done { state }
+
 }
diff --git a/amadeus-core/src/par_sink/folder.rs b/amadeus-core/src/par_sink/folder.rs
@@ -60,10 +60,13 @@ mod macros {
 pub(crate) use macros::{folder_dist_sink, folder_par_sink};
 
 pub trait FolderSync<Item> {
+	type State;
 	type Done;
 
-	fn zero(&mut self) -> Self::Done;
-	fn push(&mut self, state: &mut Self::Done, item: Item);
+	fn zero(&mut self) -> Self::State;
+	fn push(&mut self, state: &mut Self::State, item: Item);
+    fn done(&mut self, state: Self::State) -> Self::Done;
+
 }
 
 #[derive(Educe, Serialize, Deserialize, new)]
diff --git a/amadeus-core/src/par_sink/histogram.rs b/amadeus-core/src/par_sink/histogram.rs
@@ -38,25 +38,29 @@ impl<Item> FolderSync<Item> for HistogramFolder<Item, StepA>
 where
 	Item: Hash + Ord,
 {
-	type Done = HashMap<Item, usize>;
+	type State = HashMap<Item, usize>;
+	type Done = Self::State;
 
-	fn zero(&mut self) -> Self::Done {
+	fn zero(&mut self) -> Self::State {
 		HashMap::new()
 	}
 	fn push(&mut self, state: &mut Self::Done, item: Item) {
 		*state.entry(item).or_insert(0) += 1;
 	}
+    fn done(&mut self, state: Self::State) -> Self::Done { state }
+
 }
 impl<B> FolderSync<HashMap<B, usize>> for HistogramFolder<B, StepB>
 where
 	B: Hash + Ord,
 {
-	type Done = Vec<(B, usize)>;
+	type State = Vec<(B, usize)>;
+	type Done = Self::State;
 
-	fn zero(&mut self) -> Self::Done {
+	fn zero(&mut self) -> Self::State {
 		Vec::new()
 	}
-	fn push(&mut self, state: &mut Self::Done, b: HashMap<B, usize>) {
+	fn push(&mut self, state: &mut Self::State, b: HashMap<B, usize>) {
 		let mut b = b.into_iter().collect::<Vec<_>>();
 		b.sort_by(|a, b| a.0.cmp(&b.0));
 		replace_with_or_default(state, |state| {
@@ -73,17 +77,20 @@ where
 				.collect()
 		})
 	}
+    fn done(&mut self, state: Self::State) -> Self::Done { state }
+
 }
 impl<B> FolderSync<Vec<(B, usize)>> for HistogramFolder<B, StepB>
 where
 	B: Hash + Ord,
 {
-	type Done = Vec<(B, usize)>;
+	type State = Vec<(B, usize)>;
+	type Done = Self::State;
 
-	fn zero(&mut self) -> Self::Done {
+	fn zero(&mut self) -> Self::State {
 		Vec::new()
 	}
-	fn push(&mut self, state: &mut Self::Done, b: Vec<(B, usize)>) {
+	fn push(&mut self, state: &mut Self::State, b: Vec<(B, usize)>) {
 		replace_with_or_default(state, |state| {
 			state
 				.into_iter()
@@ -98,4 +105,7 @@ where
 				.collect()
 		})
 	}
+	#[inline(always)]
+    fn done(&mut self, state: Self::State) -> Self::Done { state }
+
 }
diff --git a/amadeus-core/src/par_sink/sample.rs b/amadeus-core/src/par_sink/sample.rs
@@ -38,14 +38,17 @@ pub struct SampleUnstableFolder {
 }
 
 impl<Item> FolderSync<Item> for SampleUnstableFolder {
-	type Done = SASampleUnstable<Item>;
+	type State = SASampleUnstable<Item>;
+	type Done = Self::State;
 
-	fn zero(&mut self) -> Self::Done {
+	fn zero(&mut self) -> Self::State {
 		SASampleUnstable::new(self.samples)
 	}
-	fn push(&mut self, state: &mut Self::Done, item: Item) {
+	fn push(&mut self, state: &mut Self::State, item: Item) {
 		state.push(item, &mut thread_rng())
 	}
+    fn done(&mut self, state: Self::State) -> Self::Done { state }
+
 }
 
 #[derive(new)]
@@ -83,14 +86,17 @@ impl<Item> FolderSync<Item> for MostFrequentFolder
 where
 	Item: Clone + Hash + Eq + Send + 'static,
 {
-	type Done = Top<Item, usize>;
+	type State = Top<Item, usize>;
+	type Done = Self::State;
 
-	fn zero(&mut self) -> Self::Done {
+	fn zero(&mut self) -> Self::State {
 		Top::new(self.n, self.probability, self.tolerance, ())
 	}
-	fn push(&mut self, state: &mut Self::Done, item: Item) {
+	fn push(&mut self, state: &mut Self::State, item: Item) {
 		state.push(item, &1)
 	}
+    fn done(&mut self, state: Self::State) -> Self::Done { state }
+
 }
 
 #[derive(new)]
@@ -137,12 +143,15 @@ where
 	A: Clone + Hash + Eq + Send + 'static,
 	B: Hash + 'static,
 {
-	type Done = Top<A, HyperLogLogMagnitude<B>>;
+	type State = Top<A, HyperLogLogMagnitude<B>>;
+	type Done = Self::State;
 
-	fn zero(&mut self) -> Self::Done {
+	fn zero(&mut self) -> Self::State {
 		Top::new(self.n, self.probability, self.tolerance, self.error_rate)
 	}
-	fn push(&mut self, state: &mut Self::Done, item: (A, B)) {
+	fn push(&mut self, state: &mut Self::State, item: (A, B)) {
 		state.push(item.0, &item.1)
 	}
+    fn done(&mut self, state: Self::State) -> Self::Done { state }
+
 }
diff --git a/amadeus-core/src/par_sink/stats.rs b/amadeus-core/src/par_sink/stats.rs
@@ -44,22 +44,26 @@ impl<B, Item> FolderSync<Item> for MeanFolder<B, StepA>
 where
     B: iter::Sum<Item> + iter::Sum<B>,
 {
-    type Done = (B, usize);
+    type State = (B, usize);
+    type Done = Self::State;
 
     #[inline(always)]
-    fn zero(&mut self) -> Self::Done {
+    fn zero(&mut self) -> Self::State {
         (iter::empty::<B>().sum(),0)
     }
 
     #[inline(always)]
-	fn push(&mut self, state: &mut Self::Done, item: Item) {
+	fn push(&mut self, state: &mut Self::State, item: Item) {
         let zero = iter::empty::<B>().sum();
         let left = mem::replace(&mut state.0, zero);
         let right = iter::once(item).sum::<B>();
         
         state.0 = B::sum(iter::once(left).chain(iter::once(right)));
         state.1 += 1;
     }
+
+    #[inline(always)]
+    fn done(&mut self, state: Self::State) -> Self::Done { state }
 }
 
 
@@ -68,20 +72,25 @@ impl<B> FolderSync<(B, usize)> for MeanFolder<B, StepB>
 where
     B: iter::Sum<B> 
 {
-    type Done = (B, usize);
+    type State = (B, usize);
+    type Done = Self::State;
 
     #[inline(always)]
-    fn zero(&mut self) -> Self::Done {
+    fn zero(&mut self) -> Self::State {
         (iter::empty().sum(),0)
     }
 
     #[inline(always)]
-	fn push(&mut self, state: &mut Self::Done, item: (B, usize)) {
+	fn push(&mut self, state: &mut Self::State, item: (B, usize)) {
         let zero = iter::empty().sum();
         let left = mem::replace(&mut state.0, zero);
         let right = iter::once(item.0).sum();
         
         state.0 = B::sum(iter::once(left).chain(iter::once(right)));
         state.1 += 1;
     }
+
+    #[inline(always)]
+    fn done(&mut self, state: Self::State) -> Self::Done { state }
+
 }
diff --git a/amadeus-core/src/par_sink/sum.rs b/amadeus-core/src/par_sink/sum.rs
@@ -39,19 +39,24 @@ impl<Item, B> FolderSync<Item> for SumFolder<B>
 where
 	B: iter::Sum<Item> + iter::Sum<B>,
 {
-	type Done = B;
+	type State = B;
+	type Done = Self::State;
 
 	#[inline(always)]
 	fn zero(&mut self) -> Self::Done {
 		iter::empty::<B>().sum()
 	}
 	#[inline(always)]
-	fn push(&mut self, state: &mut Self::Done, item: Item) {
+	fn push(&mut self, state: &mut Self::State, item: Item) {
 		let zero = iter::empty::<B>().sum();
 		let left = mem::replace(state, zero);
 		let right = iter::once(item).sum::<B>();
 		*state = B::sum(iter::once(left).chain(iter::once(right)));
 	}
+
+	#[inline(always)]
+    fn done(&mut self, state: Self::State) -> Self::Done { state }
+
 }
 
 #[derive(Clone, Serialize, Deserialize)]
@@ -69,18 +74,23 @@ impl<Item> FolderSync<Item> for SumZeroFolder<Item>
 where
 	Option<Item>: iter::Sum<Item>,
 {
-	type Done = Item;
+	type State = Item;
+	type Done = Self::State;
 
 	#[inline(always)]
-	fn zero(&mut self) -> Self::Done {
+	fn zero(&mut self) -> Self::State {
 		self.zero.take().unwrap()
 	}
 	#[inline(always)]
-	fn push(&mut self, state: &mut Self::Done, item: Item) {
+	fn push(&mut self, state: &mut Self::State, item: Item) {
 		replace_with_or_abort(state, |left| {
 			let right = iter::once(item).sum::<Option<Item>>().unwrap();
 			<Option<Item> as iter::Sum<Item>>::sum(iter::once(left).chain(iter::once(right)))
 				.unwrap()
 		})
 	}
+
+	#[inline(always)]
+    fn done(&mut self, state: Self::State) -> Self::Done { state }
+
 }

Original file line number	Diff line number	Diff line change
`@@ -20,12 +20,13 @@ where`
`20`	`20`	`F: FnMut<(A, A), Output = A>,`
`21`	`21`	`Item: Into<Option<A>>,`
`22`	`22`	`{`
`23`		`- type Done = Option<A>;`
	`23`	`+ type State = Option<A>;`
	`24`	`+ type Done = Self::State;`
`24`	`25`
`25`		`- fn zero(&mut self) -> Self::Done {`
	`26`	`+ fn zero(&mut self) -> Self::State {`
`26`	`27`	`None`
`27`	`28`	`}`
`28`		`- fn push(&mut self, state: &mut Self::Done, item: Item) {`
	`29`	`+ fn push(&mut self, state: &mut Self::State, item: Item) {`
`29`	`30`	`if let Some(item) = item.into() {`
`30`	`31`	`*state = Some(if let Some(state) = state.take() {`
`31`	`32`	`self.0.call_mut((state, item))`
`@@ -34,6 +35,8 @@ where`
`34`	`35`	`});`
`35`	`36`	`}`
`36`	`37`	`}`
	`38`	`+ fn done(&mut self, state: Self::State) -> Self::Done { state }`
	`39`	`+`
`37`	`40`	`}`
`38`	`41`
`39`	`42`	`#[derive(new)]`
Original file line number	Diff line number	Diff line change
`@@ -57,12 +57,13 @@ where`
`57`	`57`	`C: CombinerSync<Done = B>,`
`58`	`58`	`Item: Into<Option<B>>,`
`59`	`59`	`{`
`60`		`- type Done = Option<B>;`
	`60`	`+ type State = Option<B>;`
	`61`	`+ type Done = Self::State;`
`61`	`62`
`62`		`- fn zero(&mut self) -> Self::Done {`
	`63`	`+ fn zero(&mut self) -> Self::State {`
`63`	`64`	`None`
`64`	`65`	`}`
`65`		`- fn push(&mut self, state: &mut Self::Done, item: Item) {`
	`66`	`+ fn push(&mut self, state: &mut Self::State, item: Item) {`
`66`	`67`	`if let Some(item) = item.into() {`
`67`	`68`	`*state = Some(if let Some(state) = state.take() {`
`68`	`69`	`self.combine(state, item)`
`@@ -71,4 +72,6 @@ where`
`71`	`72`	`});`
`72`	`73`	`}`
`73`	`74`	`}`
	`75`	`+ fn done(&mut self, state: Self::State) -> Self::Done { state }`
	`76`	`+`
`74`	`77`	`}`
Original file line number	Diff line number	Diff line change
`@@ -27,14 +27,18 @@ impl_par_dist! {`
`27`	`27`	`pub struct CountFolder;`
`28`	`28`
`29`	`29`	`impl<Item> FolderSync<Item> for CountFolder {`
`30`		`- type Done = usize;`
	`30`	`+ type State = usize;`
	`31`	`+ type Done = Self::State;`
`31`	`32`
`32`	`33`	`#[inline(always)]`
`33`		`- fn zero(&mut self) -> Self::Done {`
	`34`	`+ fn zero(&mut self) -> Self::State {`
`34`	`35`	`0`
`35`	`36`	`}`
`36`	`37`	`#[inline(always)]`
`37`		`- fn push(&mut self, state: &mut Self::Done, _item: Item) {`
	`38`	`+ fn push(&mut self, state: &mut Self::State, _item: Item) {`
`38`	`39`	`*state += 1;`
`39`	`40`	`}`
	`41`	`+ #[inline(always)]`
	`42`	`+ fn done(&mut self, state: Self::State) -> Self::Done { state }`
	`43`	`+`
`40`	`44`	`}`
Original file line number	Diff line number	Diff line change
`@@ -50,28 +50,35 @@ where`
`50`	`50`	`ID: FnMut<(), Output = B>,`
`51`	`51`	`F: FnMut<(B, Either<Item, B>), Output = B>,`
`52`	`52`	`{`
`53`		`- type Done = B;`
	`53`	`+ type State = B;`
	`54`	`+ type Done = Self::State;`
`54`	`55`
`55`		`- fn zero(&mut self) -> Self::Done {`
	`56`	`+ fn zero(&mut self) -> Self::State {`
`56`	`57`	`self.identity.call_mut(())`
`57`	`58`	`}`
`58`		`- fn push(&mut self, state: &mut Self::Done, item: Item) {`
	`59`	`+ fn push(&mut self, state: &mut Self::State, item: Item) {`
`59`	`60`	`replace_with_or_abort(state, \|state\| self.op.call_mut((state, Either::Left(item))))`
`60`	`61`	`}`
	`62`	`+ fn done(&mut self, state: Self::State) -> Self::Done { state }`
	`63`	`+`
`61`	`64`	`}`
`62`	`65`	`impl<A, ID, F, Item> FolderSync<Item> for FoldFolder<A, ID, F, Item, StepB>`
`63`	`66`	`where`
`64`	`67`	`ID: FnMut<(), Output = Item>,`
`65`	`68`	`F: FnMut<(Item, Either<A, Item>), Output = Item>,`
`66`	`69`	`{`
`67`		`- type Done = Item;`
	`70`	`+ type State = Item;`
	`71`	`+ type Done = Self::State;`
`68`	`72`
`69`		`- fn zero(&mut self) -> Self::Done {`
	`73`	`+ fn zero(&mut self) -> Self::State {`
`70`	`74`	`self.identity.call_mut(())`
`71`	`75`	`}`
`72`		`- fn push(&mut self, state: &mut Self::Done, item: Item) {`
	`76`	`+ fn push(&mut self, state: &mut Self::State, item: Item) {`
`73`	`77`	`replace_with_or_abort(state, \|state\| {`
`74`	`78`	`self.op.call_mut((state, Either::Right(item)))`
`75`	`79`	`})`
`76`	`80`	`}`
	`81`	`+ #[inline(always)]`
	`82`	`+ fn done(&mut self, state: Self::State) -> Self::Done { state }`
	`83`	`+`
`77`	`84`	`}`
Original file line number	Diff line number	Diff line change
`@@ -38,25 +38,29 @@ impl<Item> FolderSync<Item> for HistogramFolder<Item, StepA>`
`38`	`38`	`where`
`39`	`39`	`Item: Hash + Ord,`
`40`	`40`	`{`
`41`		`- type Done = HashMap<Item, usize>;`
	`41`	`+ type State = HashMap<Item, usize>;`
	`42`	`+ type Done = Self::State;`
`42`	`43`
`43`		`- fn zero(&mut self) -> Self::Done {`
	`44`	`+ fn zero(&mut self) -> Self::State {`
`44`	`45`	`HashMap::new()`
`45`	`46`	`}`
`46`	`47`	`fn push(&mut self, state: &mut Self::Done, item: Item) {`
`47`	`48`	`*state.entry(item).or_insert(0) += 1;`
`48`	`49`	`}`
	`50`	`+ fn done(&mut self, state: Self::State) -> Self::Done { state }`
	`51`	`+`
`49`	`52`	`}`
`50`	`53`	`impl<B> FolderSync<HashMap<B, usize>> for HistogramFolder<B, StepB>`
`51`	`54`	`where`
`52`	`55`	`B: Hash + Ord,`
`53`	`56`	`{`
`54`		`- type Done = Vec<(B, usize)>;`
	`57`	`+ type State = Vec<(B, usize)>;`
	`58`	`+ type Done = Self::State;`
`55`	`59`
`56`		`- fn zero(&mut self) -> Self::Done {`
	`60`	`+ fn zero(&mut self) -> Self::State {`
`57`	`61`	`Vec::new()`
`58`	`62`	`}`
`59`		`- fn push(&mut self, state: &mut Self::Done, b: HashMap<B, usize>) {`
	`63`	`+ fn push(&mut self, state: &mut Self::State, b: HashMap<B, usize>) {`
`60`	`64`	`let mut b = b.into_iter().collect::<Vec<_>>();`
`61`	`65`	`b.sort_by(\|a, b\| a.0.cmp(&b.0));`
`62`	`66`	`replace_with_or_default(state, \|state\| {`
`@@ -73,17 +77,20 @@ where`
`73`	`77`	`.collect()`
`74`	`78`	`})`
`75`	`79`	`}`
	`80`	`+ fn done(&mut self, state: Self::State) -> Self::Done { state }`
	`81`	`+`
`76`	`82`	`}`
`77`	`83`	`impl<B> FolderSync<Vec<(B, usize)>> for HistogramFolder<B, StepB>`
`78`	`84`	`where`
`79`	`85`	`B: Hash + Ord,`
`80`	`86`	`{`
`81`		`- type Done = Vec<(B, usize)>;`
	`87`	`+ type State = Vec<(B, usize)>;`
	`88`	`+ type Done = Self::State;`
`82`	`89`
`83`		`- fn zero(&mut self) -> Self::Done {`
	`90`	`+ fn zero(&mut self) -> Self::State {`
`84`	`91`	`Vec::new()`
`85`	`92`	`}`
`86`		`- fn push(&mut self, state: &mut Self::Done, b: Vec<(B, usize)>) {`
	`93`	`+ fn push(&mut self, state: &mut Self::State, b: Vec<(B, usize)>) {`
`87`	`94`	`replace_with_or_default(state, \|state\| {`
`88`	`95`	`state`
`89`	`96`	`.into_iter()`
`@@ -98,4 +105,7 @@ where`
`98`	`105`	`.collect()`
`99`	`106`	`})`
`100`	`107`	`}`
	`108`	`+ #[inline(always)]`
	`109`	`+ fn done(&mut self, state: Self::State) -> Self::Done { state }`
	`110`	`+`
`101`	`111`	`}`
Original file line number	Diff line number	Diff line change
`@@ -38,14 +38,17 @@ pub struct SampleUnstableFolder {`
`38`	`38`	`}`
`39`	`39`
`40`	`40`	`impl<Item> FolderSync<Item> for SampleUnstableFolder {`
`41`		`- type Done = SASampleUnstable<Item>;`
	`41`	`+ type State = SASampleUnstable<Item>;`
	`42`	`+ type Done = Self::State;`
`42`	`43`
`43`		`- fn zero(&mut self) -> Self::Done {`
	`44`	`+ fn zero(&mut self) -> Self::State {`
`44`	`45`	`SASampleUnstable::new(self.samples)`
`45`	`46`	`}`
`46`		`- fn push(&mut self, state: &mut Self::Done, item: Item) {`
	`47`	`+ fn push(&mut self, state: &mut Self::State, item: Item) {`
`47`	`48`	`state.push(item, &mut thread_rng())`
`48`	`49`	`}`
	`50`	`+ fn done(&mut self, state: Self::State) -> Self::Done { state }`
	`51`	`+`
`49`	`52`	`}`
`50`	`53`
`51`	`54`	`#[derive(new)]`
`@@ -83,14 +86,17 @@ impl<Item> FolderSync<Item> for MostFrequentFolder`
`83`	`86`	`where`
`84`	`87`	`Item: Clone + Hash + Eq + Send + 'static,`
`85`	`88`	`{`
`86`		`- type Done = Top<Item, usize>;`
	`89`	`+ type State = Top<Item, usize>;`
	`90`	`+ type Done = Self::State;`
`87`	`91`
`88`		`- fn zero(&mut self) -> Self::Done {`
	`92`	`+ fn zero(&mut self) -> Self::State {`
`89`	`93`	`Top::new(self.n, self.probability, self.tolerance, ())`
`90`	`94`	`}`
`91`		`- fn push(&mut self, state: &mut Self::Done, item: Item) {`
	`95`	`+ fn push(&mut self, state: &mut Self::State, item: Item) {`
`92`	`96`	`state.push(item, &1)`
`93`	`97`	`}`
	`98`	`+ fn done(&mut self, state: Self::State) -> Self::Done { state }`
	`99`	`+`
`94`	`100`	`}`
`95`	`101`
`96`	`102`	`#[derive(new)]`
`@@ -137,12 +143,15 @@ where`
`137`	`143`	`A: Clone + Hash + Eq + Send + 'static,`
`138`	`144`	`B: Hash + 'static,`
`139`	`145`	`{`
`140`		`- type Done = Top<A, HyperLogLogMagnitude<B>>;`
	`146`	`+ type State = Top<A, HyperLogLogMagnitude<B>>;`
	`147`	`+ type Done = Self::State;`
`141`	`148`
`142`		`- fn zero(&mut self) -> Self::Done {`
	`149`	`+ fn zero(&mut self) -> Self::State {`
`143`	`150`	`Top::new(self.n, self.probability, self.tolerance, self.error_rate)`
`144`	`151`	`}`
`145`		`- fn push(&mut self, state: &mut Self::Done, item: (A, B)) {`
	`152`	`+ fn push(&mut self, state: &mut Self::State, item: (A, B)) {`
`146`	`153`	`state.push(item.0, &item.1)`
`147`	`154`	`}`
	`155`	`+ fn done(&mut self, state: Self::State) -> Self::Done { state }`
	`156`	`+`
`148`	`157`	`}`