From 51454750d60bbde352607e45e42cf1578aa0333d Mon Sep 17 00:00:00 2001 From: zz_y Date: Thu, 29 Oct 2026 00:01:36 +0000 Subject: [PATCH] refactor(capability): full names and upper-case acronyms for SketchAlgorithm variants Cms* -> CountMinSketch*, Kll/Hll/Kmv -> KLL/HLL/KMV (incl. Hydra and HLLHip/KLLDynamic), Elastic/Coco -> ElasticSketch/CocoSketch, MicroCm -> MicroCountMinSketch, CmsHll -> CountMinSketchHLL. Co-Authored-By: Claude Opus 5.5 --- CHANGELOG.md | 5 +- src/capability.rs | 128 ++++++++++++++++++++++---------------------- tests/capability.rs | 60 ++++++++++----------- 3 files changed, 97 insertions(+), 96 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index f6e3a23..ff0fe6e 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -17,8 +17,9 @@ signals a backwards-compatible change. family, the `StatisticKind`s one state answers, whether states merge and whether the inputs may overlap (`MergeInputRule`), and the error of each statistic read from a merged state (`MergedError`). - `SketchAlgorithm::ALL` lists the families. The names are the ASAPPlanner's, - which reads the table directly; the enums are exhaustive and serde-derived. + `SketchAlgorithm::ALL` lists the families. Variants use full names and + upper-case acronyms (`CountMinSketch`, `HydraKLL`, `HLL`); the ASAPPlanner + reads the table directly; the enums are exhaustive and serde-derived. Rows list each sketch's own estimates only: exact aggregates kept in side fields next to a sketch (DDSketch's sum/min/max, a Space-Saving total) are a separate exact operator (#250); a total read from the sketch's own diff --git a/src/capability.rs b/src/capability.rs index e10155b..c4d5a27 100644 --- a/src/capability.rs +++ b/src/capability.rs @@ -17,31 +17,31 @@ )] pub enum SketchAlgorithm { /// `CountMinSketch` over every storage and path, and `CountMinF64`. - Cms, + CountMinSketch, CountSketch, CountSketchWithL2Norm, /// `CountMinSketchWithHeap`. - CmsWithHeap, + CountMinSketchWithHeap, CountSketchWithHeap, /// `CountMinSketchWithSpaceSaving`. - CmsWithSpaceSaving, + CountMinSketchWithSpaceSaving, CountSketchWithSpaceSaving, /// `CountMinSketchFold`. - CmsFold, + CountMinSketchFold, CountSketchFold, /// `HyperLogLog` (Classic or Ertl) at any precision. - Hll, + HLL, /// `HyperLogLogHip` at any precision. - HllHip, - Kmv, - Kll, - KllDynamic, + HLLHip, + KMV, + KLL, + KLLDynamic, DDSketch, SpaceSaving, /// `ElasticSketch`. - Elastic, + ElasticSketch, /// `CocoSketch`. - Coco, + CocoSketch, Bloom, SetAggregator, UnivMon, @@ -49,19 +49,19 @@ pub enum SketchAlgorithm { /// Quantile and rank are `None` when `ordered_samples` is 0. UnivMonQ, /// `Hydra` over Count-Min cells, per subpopulation. - HydraCms, + HydraCountMinSketch, /// `Hydra` over Count Sketch cells, per subpopulation. HydraCountSketch, /// `Hydra` over KLL cells, per subpopulation. - HydraKll, + HydraKLL, /// `Hydra` over HyperLogLog cells, per subpopulation. - HydraHll, + HydraHLL, /// `Hydra` over UnivMon cells, per subpopulation. HydraUnivMon, #[cfg(feature = "experimental")] - CmsHll, + CountMinSketchHLL, #[cfg(feature = "experimental")] - MicroCm, + MicroCountMinSketch, #[cfg(feature = "experimental")] UniformSampling, } @@ -112,7 +112,7 @@ pub enum MergedError { Exact, /// As one state built over the union, given equal parameters: the merge /// adds no error of its own. Whatever guarantee one state has, the merged - /// state keeps; a family with none (HydraKll) gains none. + /// state keeps; a family with none (HydraKLL) gains none. AsIfBuiltOverUnion, /// The merge is allowed, but the merged readout has no guarantee. Approximate, @@ -149,38 +149,38 @@ impl FamilyCapability { impl SketchAlgorithm { /// Every family, each once. pub const ALL: &'static [SketchAlgorithm] = &[ - SketchAlgorithm::Cms, + SketchAlgorithm::CountMinSketch, SketchAlgorithm::CountSketch, SketchAlgorithm::CountSketchWithL2Norm, - SketchAlgorithm::CmsWithHeap, + SketchAlgorithm::CountMinSketchWithHeap, SketchAlgorithm::CountSketchWithHeap, - SketchAlgorithm::CmsWithSpaceSaving, + SketchAlgorithm::CountMinSketchWithSpaceSaving, SketchAlgorithm::CountSketchWithSpaceSaving, - SketchAlgorithm::CmsFold, + SketchAlgorithm::CountMinSketchFold, SketchAlgorithm::CountSketchFold, - SketchAlgorithm::Hll, - SketchAlgorithm::HllHip, - SketchAlgorithm::Kmv, - SketchAlgorithm::Kll, - SketchAlgorithm::KllDynamic, + SketchAlgorithm::HLL, + SketchAlgorithm::HLLHip, + SketchAlgorithm::KMV, + SketchAlgorithm::KLL, + SketchAlgorithm::KLLDynamic, SketchAlgorithm::DDSketch, SketchAlgorithm::SpaceSaving, - SketchAlgorithm::Elastic, - SketchAlgorithm::Coco, + SketchAlgorithm::ElasticSketch, + SketchAlgorithm::CocoSketch, SketchAlgorithm::Bloom, SketchAlgorithm::SetAggregator, SketchAlgorithm::UnivMon, SketchAlgorithm::UnivMonTwoTier, SketchAlgorithm::UnivMonQ, - SketchAlgorithm::HydraCms, + SketchAlgorithm::HydraCountMinSketch, SketchAlgorithm::HydraCountSketch, - SketchAlgorithm::HydraKll, - SketchAlgorithm::HydraHll, + SketchAlgorithm::HydraKLL, + SketchAlgorithm::HydraHLL, SketchAlgorithm::HydraUnivMon, #[cfg(feature = "experimental")] - SketchAlgorithm::CmsHll, + SketchAlgorithm::CountMinSketchHLL, #[cfg(feature = "experimental")] - SketchAlgorithm::MicroCm, + SketchAlgorithm::MicroCountMinSketch, #[cfg(feature = "experimental")] SketchAlgorithm::UniformSampling, ]; @@ -199,25 +199,25 @@ impl SketchAlgorithm { ]; const FREQUENCY_TOP_K: &[(StatisticKind, MergedError)] = &[(ItemFrequency, U), (TopK, A)]; let (merge_inputs, readouts): (_, &'static [(StatisticKind, MergedError)]) = match self { - Self::Cms => (Some(Disjoint), &[(ItemFrequency, U), (Total, E)]), + Self::CountMinSketch => (Some(Disjoint), &[(ItemFrequency, U), (Total, E)]), Self::CountSketch => (Some(Disjoint), &[(ItemFrequency, U)]), Self::CountSketchWithL2Norm => { (Some(Disjoint), &[(ItemFrequency, U), (FrequencyL2, U)]) } - Self::CmsWithHeap + Self::CountMinSketchWithHeap | Self::CountSketchWithHeap - | Self::CmsWithSpaceSaving + | Self::CountMinSketchWithSpaceSaving | Self::CountSketchWithSpaceSaving - | Self::CmsFold + | Self::CountMinSketchFold | Self::CountSketchFold => (Some(Disjoint), FREQUENCY_TOP_K), - Self::Hll => (Some(MayOverlap), &[(Distinct, U)]), - Self::HllHip => (None, &[(Distinct, A)]), - Self::Kmv => (Some(MayOverlap), &[(Distinct, U)]), - Self::Kll | Self::KllDynamic => (Some(Disjoint), &[(Quantile, U), (Rank, U)]), + Self::HLL => (Some(MayOverlap), &[(Distinct, U)]), + Self::HLLHip => (None, &[(Distinct, A)]), + Self::KMV => (Some(MayOverlap), &[(Distinct, U)]), + Self::KLL | Self::KLLDynamic => (Some(Disjoint), &[(Quantile, U), (Rank, U)]), Self::DDSketch => (Some(Disjoint), &[(Quantile, U)]), Self::SpaceSaving => (Some(Disjoint), &[(ItemFrequency, A), (TopK, A)]), - Self::Elastic => (Some(Disjoint), &[(ItemFrequency, A), (TopK, A)]), - Self::Coco => (Some(Disjoint), &[(ItemFrequency, A), (PartialKeySum, A)]), + Self::ElasticSketch => (Some(Disjoint), &[(ItemFrequency, A), (TopK, A)]), + Self::CocoSketch => (Some(Disjoint), &[(ItemFrequency, A), (PartialKeySum, A)]), Self::Bloom => (Some(MayOverlap), &[(Membership, U)]), Self::SetAggregator => (Some(MayOverlap), &[(Distinct, E), (Membership, E)]), Self::UnivMon | Self::UnivMonTwoTier => (Some(Disjoint), UNIVMON), @@ -238,10 +238,10 @@ impl SketchAlgorithm { (TopK, A), ], ), - Self::HydraCms => (Some(Disjoint), &[(ItemFrequency, U), (Total, U)]), + Self::HydraCountMinSketch => (Some(Disjoint), &[(ItemFrequency, U), (Total, U)]), Self::HydraCountSketch => (Some(Disjoint), &[(ItemFrequency, U)]), - Self::HydraKll => (Some(Disjoint), &[(Quantile, U), (Rank, U)]), - Self::HydraHll => (Some(MayOverlap), &[(Distinct, U)]), + Self::HydraKLL => (Some(Disjoint), &[(Quantile, U), (Rank, U)]), + Self::HydraHLL => (Some(MayOverlap), &[(Distinct, U)]), Self::HydraUnivMon => ( Some(Disjoint), &[ @@ -252,9 +252,9 @@ impl SketchAlgorithm { ], ), #[cfg(feature = "experimental")] - Self::CmsHll => (Some(MayOverlap), &[(KeyDistinct, U)]), + Self::CountMinSketchHLL => (Some(MayOverlap), &[(KeyDistinct, U)]), #[cfg(feature = "experimental")] - Self::MicroCm => (Some(Disjoint), &[(ItemFrequency, A)]), + Self::MicroCountMinSketch => (Some(Disjoint), &[(ItemFrequency, A)]), #[cfg(feature = "experimental")] Self::UniformSampling => (Some(Disjoint), &[(Sample, A)]), }; @@ -272,38 +272,38 @@ mod tests { /// No wildcard: a new variant fails to compile until listed here. fn expected_index(family: SketchAlgorithm) -> usize { match family { - SketchAlgorithm::Cms => 0, + SketchAlgorithm::CountMinSketch => 0, SketchAlgorithm::CountSketch => 1, SketchAlgorithm::CountSketchWithL2Norm => 2, - SketchAlgorithm::CmsWithHeap => 3, + SketchAlgorithm::CountMinSketchWithHeap => 3, SketchAlgorithm::CountSketchWithHeap => 4, - SketchAlgorithm::CmsWithSpaceSaving => 5, + SketchAlgorithm::CountMinSketchWithSpaceSaving => 5, SketchAlgorithm::CountSketchWithSpaceSaving => 6, - SketchAlgorithm::CmsFold => 7, + SketchAlgorithm::CountMinSketchFold => 7, SketchAlgorithm::CountSketchFold => 8, - SketchAlgorithm::Hll => 9, - SketchAlgorithm::HllHip => 10, - SketchAlgorithm::Kmv => 11, - SketchAlgorithm::Kll => 12, - SketchAlgorithm::KllDynamic => 13, + SketchAlgorithm::HLL => 9, + SketchAlgorithm::HLLHip => 10, + SketchAlgorithm::KMV => 11, + SketchAlgorithm::KLL => 12, + SketchAlgorithm::KLLDynamic => 13, SketchAlgorithm::DDSketch => 14, SketchAlgorithm::SpaceSaving => 15, - SketchAlgorithm::Elastic => 16, - SketchAlgorithm::Coco => 17, + SketchAlgorithm::ElasticSketch => 16, + SketchAlgorithm::CocoSketch => 17, SketchAlgorithm::Bloom => 18, SketchAlgorithm::SetAggregator => 19, SketchAlgorithm::UnivMon => 20, SketchAlgorithm::UnivMonTwoTier => 21, SketchAlgorithm::UnivMonQ => 22, - SketchAlgorithm::HydraCms => 23, + SketchAlgorithm::HydraCountMinSketch => 23, SketchAlgorithm::HydraCountSketch => 24, - SketchAlgorithm::HydraKll => 25, - SketchAlgorithm::HydraHll => 26, + SketchAlgorithm::HydraKLL => 25, + SketchAlgorithm::HydraHLL => 26, SketchAlgorithm::HydraUnivMon => 27, #[cfg(feature = "experimental")] - SketchAlgorithm::CmsHll => 28, + SketchAlgorithm::CountMinSketchHLL => 28, #[cfg(feature = "experimental")] - SketchAlgorithm::MicroCm => 29, + SketchAlgorithm::MicroCountMinSketch => 29, #[cfg(feature = "experimental")] SketchAlgorithm::UniformSampling => 30, } diff --git a/tests/capability.rs b/tests/capability.rs index b66ce28..942ba79 100644 --- a/tests/capability.rs +++ b/tests/capability.rs @@ -23,24 +23,24 @@ const QUANTILE_RANK: Readouts = &[(Quantile, U), (Rank, U)]; #[rustfmt::skip] const DECIDED: &[(SketchAlgorithm, Option, Readouts)] = &[ - (F::Cms, Some(D), &[(ItemFrequency, U), (Total, E)]), + (F::CountMinSketch, Some(D), &[(ItemFrequency, U), (Total, E)]), (F::CountSketch, Some(D), &[(ItemFrequency, U)]), (F::CountSketchWithL2Norm, Some(D), &[(ItemFrequency, U), (FrequencyL2, U)]), - (F::CmsWithHeap, Some(D), FREQ_TOP_K), + (F::CountMinSketchWithHeap, Some(D), FREQ_TOP_K), (F::CountSketchWithHeap, Some(D), FREQ_TOP_K), - (F::CmsWithSpaceSaving, Some(D), FREQ_TOP_K), + (F::CountMinSketchWithSpaceSaving, Some(D), FREQ_TOP_K), (F::CountSketchWithSpaceSaving, Some(D), FREQ_TOP_K), - (F::CmsFold, Some(D), FREQ_TOP_K), + (F::CountMinSketchFold, Some(D), FREQ_TOP_K), (F::CountSketchFold, Some(D), FREQ_TOP_K), - (F::Hll, Some(O), &[(Distinct, U)]), - (F::HllHip, None, &[(Distinct, A)]), - (F::Kmv, Some(O), &[(Distinct, U)]), - (F::Kll, Some(D), QUANTILE_RANK), - (F::KllDynamic, Some(D), QUANTILE_RANK), + (F::HLL, Some(O), &[(Distinct, U)]), + (F::HLLHip, None, &[(Distinct, A)]), + (F::KMV, Some(O), &[(Distinct, U)]), + (F::KLL, Some(D), QUANTILE_RANK), + (F::KLLDynamic, Some(D), QUANTILE_RANK), (F::DDSketch, Some(D), &[(Quantile, U)]), (F::SpaceSaving, Some(D), &[(ItemFrequency, A), (TopK, A)]), - (F::Elastic, Some(D), &[(ItemFrequency, A), (TopK, A)]), - (F::Coco, Some(D), &[(ItemFrequency, A), (PartialKeySum, A)]), + (F::ElasticSketch, Some(D), &[(ItemFrequency, A), (TopK, A)]), + (F::CocoSketch, Some(D), &[(ItemFrequency, A), (PartialKeySum, A)]), (F::Bloom, Some(O), &[(Membership, U)]), (F::SetAggregator, Some(O), &[(Distinct, E), (Membership, E)]), (F::UnivMon, Some(D), UNIVMON), @@ -49,15 +49,15 @@ const DECIDED: &[(SketchAlgorithm, Option, Readouts)] = &[ (ItemFrequency, U), (FrequencyL2, U), (Distinct, A), (Quantile, A), (Rank, A), (GSum, A), (FrequencyEntropy, A), (TopK, A), ]), - (F::HydraCms, Some(D), &[(ItemFrequency, U), (Total, U)]), + (F::HydraCountMinSketch, Some(D), &[(ItemFrequency, U), (Total, U)]), (F::HydraCountSketch, Some(D), &[(ItemFrequency, U)]), - (F::HydraKll, Some(D), QUANTILE_RANK), - (F::HydraHll, Some(O), &[(Distinct, U)]), + (F::HydraKLL, Some(D), QUANTILE_RANK), + (F::HydraHLL, Some(O), &[(Distinct, U)]), (F::HydraUnivMon, Some(D), &[(Total, U), (Distinct, U), (FrequencyL2, U), (FrequencyEntropy, A)]), #[cfg(feature = "experimental")] - (F::CmsHll, Some(O), &[(KeyDistinct, U)]), + (F::CountMinSketchHLL, Some(O), &[(KeyDistinct, U)]), #[cfg(feature = "experimental")] - (F::MicroCm, Some(D), &[(ItemFrequency, A)]), + (F::MicroCountMinSketch, Some(D), &[(ItemFrequency, A)]), #[cfg(feature = "experimental")] (F::UniformSampling, Some(D), &[(Sample, A)]), ]; @@ -77,8 +77,8 @@ fn every_row_is_well_formed() { assert_eq!(row.merged_error(statistic), row.merge_inputs.map(|_| error)); } } - assert_eq!(F::HllHip.capability().merged_error(Distinct), None); - assert_eq!(F::Cms.capability().merged_error(Quantile), None); + assert_eq!(F::HLLHip.capability().merged_error(Distinct), None); + assert_eq!(F::CountMinSketch.capability().merged_error(Quantile), None); } #[test] @@ -130,33 +130,33 @@ fn probe(family: SketchAlgorithm) -> Vec<(StatisticKind, f64, f64)> { let query = |h: &Hydra, q: HydraQuery| h.query_key(&G, &q).unwrap(); let keys = |n: u64| (0..n).map(DataInput::U64); match family { - F::Cms => self_merge(CountMinSketch::, FastPath>::with_dimensions(3, 64), |s| s.update_weighted(&K, 3), + F::CountMinSketch => self_merge(CountMinSketch::, FastPath>::with_dimensions(3, 64), |s| s.update_weighted(&K, 3), |a, b| a.merge(b), |s| vec![(Total, s.total()), (ItemFrequency, s.estimate(&K) as f64)]), F::CountSketch => self_merge(CountSketch::, FastPath>::with_dimensions(3, 64), |s| s.update_weighted(&K, 3), |a, b| a.merge(b), |s| vec![(ItemFrequency, s.estimate(&K))]), F::CountSketchWithL2Norm => self_merge(CountSketchWithL2Norm::::with_dimensions(3, 64), |s| s.update_weighted(&K, 3), |a, b| a.merge(b), |s| vec![(ItemFrequency, s.estimate(&K))]), - F::CmsWithHeap => self_merge(CountMinSketchWithHeap::, FastPath>::new(3, 64, 4), + F::CountMinSketchWithHeap => self_merge(CountMinSketchWithHeap::, FastPath>::new(3, 64, 4), |s| s.update_weighted(&K, 3), |a, b| a.merge(b), |s| vec![(ItemFrequency, s.estimate(&K) as f64)]), F::CountSketchWithHeap => self_merge(CountSketchWithHeap::, FastPath>::new(3, 64, 4), |s| s.update_weighted(&K, 3), |a, b| a.merge(b), |s| vec![(ItemFrequency, s.estimate(&K))]), - F::CmsWithSpaceSaving => self_merge(CountMinSketchWithSpaceSaving::>::new(3, 64, 4), + F::CountMinSketchWithSpaceSaving => self_merge(CountMinSketchWithSpaceSaving::>::new(3, 64, 4), |s| s.update_weighted(&K, 3), |a, b| a.merge(b), |s| vec![(ItemFrequency, s.estimate(&K) as f64)]), F::CountSketchWithSpaceSaving => self_merge(CountSketchWithSpaceSaving::>::new(3, 64, 4), |s| s.update_weighted(&K, 3), |a, b| a.merge(b), |s| vec![(ItemFrequency, s.estimate(&K))]), - F::CmsFold => self_merge(CountMinSketchFold::::new(3, 64, 2, 4), |s| s.update_weighted(&K, 3), + F::CountMinSketchFold => self_merge(CountMinSketchFold::::new(3, 64, 2, 4), |s| s.update_weighted(&K, 3), |a, b| a.merge_same_level(b), |s| vec![(ItemFrequency, s.estimate(&K) as f64)]), F::CountSketchFold => self_merge(CountSketchFold::::new(3, 64, 2, 4), |s| s.update_weighted(&K, 3), |a, b| a.merge_same_level(b), |s| vec![(ItemFrequency, s.estimate(&K) as f64)]), - F::Hll => self_merge(HyperLogLog::::new(), |s| keys(50).for_each(|k| s.update(&k)), + F::HLL => self_merge(HyperLogLog::::new(), |s| keys(50).for_each(|k| s.update(&k)), |a, b| a.merge(b), |s| vec![(Distinct, s.estimate() as f64)]), - F::Kmv => self_merge(Kmv::::new(16), |s| keys(50).for_each(|k| s.update(&k)), + F::KMV => self_merge(Kmv::::new(16), |s| keys(50).for_each(|k| s.update(&k)), |a, b| a.merge(b), |s| vec![(Distinct, s.estimate())]), F::SpaceSaving => self_merge(SpaceSaving::::with_capacity(4), |s| s.update_weighted(&K, 3), |a, b| a.merge(b), |s| vec![(ItemFrequency, s.estimate(&K) as f64)]), - F::Elastic => self_merge(ElasticSketch::::with_heavy_buckets(8), |s| s.update_weighted("a".into(), 3), + F::ElasticSketch => self_merge(ElasticSketch::::with_heavy_buckets(8), |s| s.update_weighted("a".into(), 3), |a, b| a.merge(b), |s| vec![(ItemFrequency, s.estimate("a".into()) as f64)]), - F::Coco => self_merge(CocoSketch::::with_dimensions(3, 64), |s| s.update_weighted("a", 3), + F::CocoSketch => self_merge(CocoSketch::::with_dimensions(3, 64), |s| s.update_weighted("a", 3), |a, b| a.merge(b), |s| vec![(ItemFrequency, s.estimate("a") as f64)]), F::Bloom => self_merge(Bloom::::with_capacity(100, 0.01), |s| s.update(&K), |a, b| a.merge(b), |s| vec![(Membership, s.contains(&K) as u8 as f64)]), @@ -168,19 +168,19 @@ fn probe(family: SketchAlgorithm) -> Vec<(StatisticKind, f64, f64)> { |a, b| a.merge(b), |s| vec![(Total, s.estimate_l1())]), F::UnivMonQ => self_merge(UnivMonQ::::default(), |s| (0..3).for_each(|_| s.update(&3.0f64)), |a, b| a.merge(b).unwrap(), |s| vec![(ItemFrequency, s.estimate_frequency(3.0) as f64)]), - F::HydraCms => self_merge(hydra(HydraCounter::CountMinSketch(CountMinSketch::with_dimensions(3, 64))), add3, merge, + F::HydraCountMinSketch => self_merge(hydra(HydraCounter::CountMinSketch(CountMinSketch::with_dimensions(3, 64))), add3, merge, |s| vec![(Total, s.query_group_total(&G).unwrap()), (ItemFrequency, s.query_frequency(&G, &K).unwrap())]), F::HydraCountSketch => self_merge(hydra(HydraCounter::CountSketch(CountSketch::with_dimensions(3, 64))), add3, merge, |s| vec![(ItemFrequency, s.query_frequency(&G, &K).unwrap())]), - F::HydraHll => self_merge(hydra(HydraCounter::Hll(HyperLogLog::::new())), add3, merge, + F::HydraHLL => self_merge(hydra(HydraCounter::Hll(HyperLogLog::::new())), add3, merge, |s| vec![(Distinct, query(s, HydraQuery::Cardinality))]), F::HydraUnivMon => self_merge(hydra(HydraCounter::UnivMon(UnivMon::new(4, 3, 64, 4))), add3, merge, |s| vec![(Total, query(s, HydraQuery::L1Norm))]), #[cfg(feature = "experimental")] - F::CmsHll => self_merge(CountMinHll::::with_dimensions(3, 64, 10), + F::CountMinSketchHLL => self_merge(CountMinHll::::with_dimensions(3, 64, 10), |s| keys(20).for_each(|v| s.update(&K, &v)), |a, b| a.merge(b).unwrap(), |s| vec![(KeyDistinct, s.estimate(&K))]), #[cfg(feature = "experimental")] - F::MicroCm => self_merge(MicroCm::default(), |s| (0..3).for_each(|_| s.update(&K)), + F::MicroCountMinSketch => self_merge(MicroCm::default(), |s| (0..3).for_each(|_| s.update(&K)), |a, b| a.merge(b).unwrap(), |s| vec![(ItemFrequency, s.estimate(&K))]), _ => vec![], }