You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@datasketches.apache.org by ti...@apache.org on 2026/07/23 12:39:49 UTC

(datasketches-rust) branch main updated: refactor: simplify builders interface and rework tuple summary policy (#158)

This is an automated email from the ASF dual-hosted git repository.

tisonkun pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/datasketches-rust.git


The following commit(s) were added to refs/heads/main by this push:
     new 7f35b05  refactor: simplify builders interface and rework tuple summary policy (#158)
7f35b05 is described below

commit 7f35b0510029740a38338ccaf587a07ab4426ee3
Author: tison <wa...@gmail.com>
AuthorDate: Thu Jul 23 20:39:44 2026 +0800

    refactor: simplify builders interface and rework tuple summary policy (#158)
    
    Signed-off-by: tison <wa...@gmail.com>
---
 CHANGELOG.md                                  |   4 +
 datasketches/src/countmin/mod.rs              |   3 +-
 datasketches/src/hll/union.rs                 |   6 +-
 datasketches/src/theta/hash_table.rs          |  12 +-
 datasketches/src/theta/mod.rs                 |   4 +-
 datasketches/src/theta/sketch.rs              |  78 +++---
 datasketches/src/theta/union.rs               |  30 +--
 datasketches/src/tuple/mod.rs                 |  13 +-
 datasketches/src/tuple/policy.rs              |  68 +++---
 datasketches/src/tuple/sketch.rs              | 329 +++++++++++++++-----------
 datasketches/tests/cpc_union_test.rs          |   4 +-
 datasketches/tests/frequencies_update_test.rs |   2 +-
 datasketches/tests/theta_intersection_test.rs |  31 +--
 datasketches/tests/theta_sketch_test.rs       |  34 +--
 datasketches/tests/theta_union_test.rs        |  93 ++++----
 datasketches/tests/tuple_sketch_test.rs       |  53 ++---
 16 files changed, 406 insertions(+), 358 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index e7ada56..da6cb3f 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,6 +4,10 @@ All significant changes to this project will be documented in this file.
 
 ## Unreleased
 
+### Breaking changes
+
+* Remove `ThetaSketch::builder`, `ThetaUnion::builder`, and `TupleSketch::builder`. Construct `ThetaSketchBuilder`, `ThetaUnionBuilder`, and `TupleSketchBuilder` with `Default::default` instead.
+
 ### New features
 
 * `FrequentItemsSketch` now supports borrowed-key updates via `update_ref` and `update_with_count_ref`, allowing sketches such as `FrequentItemsSketch<String>` to update from `&str` without allocating on existing-key hits. Frequency queries also accept borrowed key forms matching `Borrow<Q>`.
diff --git a/datasketches/src/countmin/mod.rs b/datasketches/src/countmin/mod.rs
index cea20ae..4331c20 100644
--- a/datasketches/src/countmin/mod.rs
+++ b/datasketches/src/countmin/mod.rs
@@ -36,7 +36,8 @@
 //! # use datasketches::countmin::CountMinSketch;
 //! let buckets = CountMinSketch::<i64>::suggest_num_buckets(0.01);
 //! let hashes = CountMinSketch::<i64>::suggest_num_hashes(0.99);
-//! let _sketch = CountMinSketch::<i64>::new(hashes, buckets);
+//! let sketch = CountMinSketch::<i64>::new(hashes, buckets);
+//! assert_eq!(sketch.estimate("apple"), 0);
 //! ```
 
 mod serialization;
diff --git a/datasketches/src/hll/union.rs b/datasketches/src/hll/union.rs
index 9d0fd06..df995f6 100644
--- a/datasketches/src/hll/union.rs
+++ b/datasketches/src/hll/union.rs
@@ -74,7 +74,8 @@ impl HllUnion {
     /// # use datasketches::hll::HllUnion;
     /// let mut union = HllUnion::new(10);
     /// union.update_value("apple");
-    /// let _result = union.to_sketch(HllType::Hll8);
+    /// let result = union.to_sketch(HllType::Hll8);
+    /// assert_eq!(result.estimate(), 1.0);
     /// ```
     pub fn new(lg_max_k: u8) -> Self {
         assert!(
@@ -101,7 +102,8 @@ impl HllUnion {
     /// # use datasketches::hll::HllUnion;
     /// let mut union = HllUnion::new(10);
     /// union.update_value("apple");
-    /// let _result = union.to_sketch(HllType::Hll8);
+    /// let result = union.to_sketch(HllType::Hll8);
+    /// assert_eq!(result.estimate(), 1.0);
     /// ```
     pub fn update_value<T: Hash>(&mut self, value: T) {
         self.gadget.update(value);
diff --git a/datasketches/src/theta/hash_table.rs b/datasketches/src/theta/hash_table.rs
index fa9036b..5dd83ee 100644
--- a/datasketches/src/theta/hash_table.rs
+++ b/datasketches/src/theta/hash_table.rs
@@ -217,7 +217,7 @@ mod tests {
 
         // Insert many values to trigger rebuild
         for i in 0..100 {
-            let _ = table.try_insert(format!("value_{}", i));
+            table.try_insert(format!("value_{i}"));
         }
 
         // After rebuild, theta should be reduced (rebuild is called automatically during insert)
@@ -229,7 +229,7 @@ mod tests {
 
         // Continue to insert values to trigger rebuild again
         for i in 100..200 {
-            let _ = table.try_insert(format!("value_{}", i));
+            table.try_insert(format!("value_{i}"));
         }
 
         assert_eq!(table.lg_cur_size(), 6);
@@ -243,7 +243,7 @@ mod tests {
 
         // Insert more than k values
         for i in 0..100 {
-            let _ = table.try_insert(format!("value_{}", i));
+            table.try_insert(format!("value_{i}"));
         }
 
         let before_trim = table.num_retained();
@@ -261,7 +261,7 @@ mod tests {
 
         // Insert fewer than k values
         for i in 0..10 {
-            let _ = table.try_insert(format!("value_{}", i));
+            table.try_insert(format!("value_{i}"));
         }
 
         let before_trim = table.num_retained();
@@ -283,7 +283,7 @@ mod tests {
 
         // Insert some values
         for i in 0..10 {
-            let _ = table.try_insert(format!("value_{}", i));
+            table.try_insert(format!("value_{i}"));
         }
 
         assert!(!table.is_empty());
@@ -312,7 +312,7 @@ mod tests {
 
         // Insert some values
         for i in 0..10 {
-            let _ = table.try_insert(format!("value_{}", i));
+            table.try_insert(format!("value_{i}"));
         }
 
         table.reset();
diff --git a/datasketches/src/theta/mod.rs b/datasketches/src/theta/mod.rs
index 10bfa3e..0178f34 100644
--- a/datasketches/src/theta/mod.rs
+++ b/datasketches/src/theta/mod.rs
@@ -33,8 +33,8 @@
 //! # Usage
 //!
 //! ```
-//! # use datasketches::theta::ThetaSketch;
-//! let mut sketch = ThetaSketch::builder().build();
+//! # use datasketches::theta::ThetaSketchBuilder;
+//! let mut sketch = ThetaSketchBuilder::default().build();
 //! sketch.update("apple");
 //! assert!(sketch.estimate() >= 1.0);
 //! ```
diff --git a/datasketches/src/theta/sketch.rs b/datasketches/src/theta/sketch.rs
index 1d26c8d..0ccbf61 100644
--- a/datasketches/src/theta/sketch.rs
+++ b/datasketches/src/theta/sketch.rs
@@ -95,19 +95,6 @@ pub struct ThetaSketch {
 }
 
 impl ThetaSketch {
-    /// Create a new builder for ThetaSketch
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # use datasketches::theta::ThetaSketch;
-    /// let sketch = ThetaSketch::builder().lg_k(12).build();
-    /// assert_eq!(sketch.lg_k(), 12);
-    /// ```
-    pub fn builder() -> ThetaSketchBuilder {
-        ThetaSketchBuilder::default()
-    }
-
     /// Update the sketch with a hashable value.
     ///
     /// You may use [`hash_value`](crate::hash_value) wrappers when matching other datasketches
@@ -117,13 +104,13 @@ impl ThetaSketch {
     ///
     /// ```
     /// use datasketches::hash_value;
-    /// use datasketches::theta::ThetaSketch;
+    /// use datasketches::theta::ThetaSketchBuilder;
     ///
-    /// let mut sketch = ThetaSketch::builder().build();
+    /// let mut sketch = ThetaSketchBuilder::default().build();
     /// sketch.update("apple");
     /// assert!(sketch.estimate() >= 1.0);
     ///
-    /// let mut sketch = ThetaSketch::builder().build();
+    /// let mut sketch = ThetaSketchBuilder::default().build();
     /// sketch.update(hash_value::raw_bytes::from_str("apple"));
     /// assert!(sketch.estimate() >= 1.0);
     /// ```
@@ -136,8 +123,8 @@ impl ThetaSketch {
     /// # Examples
     ///
     /// ```
-    /// # use datasketches::theta::ThetaSketch;
-    /// # let mut sketch = ThetaSketch::builder().build();
+    /// # use datasketches::theta::ThetaSketchBuilder;
+    /// # let mut sketch = ThetaSketchBuilder::default().build();
     /// # sketch.update("apple");
     /// assert!(sketch.estimate() >= 1.0);
     /// ```
@@ -200,8 +187,8 @@ impl ThetaSketch {
     /// # Examples
     ///
     /// ```
-    /// # use datasketches::theta::ThetaSketch;
-    /// # let mut sketch = ThetaSketch::builder().build();
+    /// # use datasketches::theta::ThetaSketchBuilder;
+    /// # let mut sketch = ThetaSketchBuilder::default().build();
     /// # sketch.update("apple");
     /// let mut iter = sketch.iter();
     /// assert!(iter.next().is_some());
@@ -217,8 +204,8 @@ impl ThetaSketch {
     /// # Examples
     ///
     /// ```
-    /// # use datasketches::theta::ThetaSketch;
-    /// let mut sketch = ThetaSketch::builder().build();
+    /// # use datasketches::theta::ThetaSketchBuilder;
+    /// let mut sketch = ThetaSketchBuilder::default().build();
     /// sketch.update("apple");
     /// let compact = sketch.compact(true);
     /// assert_eq!(compact.num_retained(), 1);
@@ -248,9 +235,9 @@ impl ThetaSketch {
     ///
     /// ```
     /// use datasketches::common::NumStdDev;
-    /// use datasketches::theta::ThetaSketch;
+    /// use datasketches::theta::ThetaSketchBuilder;
     ///
-    /// let mut sketch = ThetaSketch::builder().lg_k(12).build();
+    /// let mut sketch = ThetaSketchBuilder::default().lg_k(12).build();
     /// for i in 0..10000 {
     ///     sketch.update(i);
     /// }
@@ -282,9 +269,9 @@ impl ThetaSketch {
     ///
     /// ```
     /// use datasketches::common::NumStdDev;
-    /// use datasketches::theta::ThetaSketch;
+    /// use datasketches::theta::ThetaSketchBuilder;
     ///
-    /// let mut sketch = ThetaSketch::builder().lg_k(12).build();
+    /// let mut sketch = ThetaSketchBuilder::default().lg_k(12).build();
     /// for i in 0..10000 {
     ///     sketch.update(i);
     /// }
@@ -931,8 +918,8 @@ impl ThetaSketchBuilder {
     /// # Examples
     ///
     /// ```
-    /// # use datasketches::theta::ThetaSketch;
-    /// let sketch = ThetaSketch::builder().lg_k(12).build();
+    /// # use datasketches::theta::ThetaSketchBuilder;
+    /// let sketch = ThetaSketchBuilder::default().lg_k(12).build();
     /// assert_eq!(sketch.lg_k(), 12);
     /// ```
     pub fn lg_k(mut self, lg_k: u8) -> Self {
@@ -965,8 +952,10 @@ impl ThetaSketchBuilder {
     /// # Examples
     ///
     /// ```
-    /// # use datasketches::theta::ThetaSketch;
-    /// let _sketch = ThetaSketch::builder().sampling_probability(0.5).build();
+    /// # use datasketches::theta::ThetaSketchBuilder;
+    /// ThetaSketchBuilder::default()
+    ///     .sampling_probability(0.5)
+    ///     .build();
     /// ```
     pub fn sampling_probability(mut self, probability: f32) -> Self {
         assert!(
@@ -982,8 +971,8 @@ impl ThetaSketchBuilder {
     /// # Examples
     ///
     /// ```
-    /// # use datasketches::theta::ThetaSketch;
-    /// let _sketch = ThetaSketch::builder().seed(7).build();
+    /// # use datasketches::theta::ThetaSketchBuilder;
+    /// ThetaSketchBuilder::default().seed(7).build();
     /// ```
     pub fn seed(mut self, seed: u64) -> Self {
         self.seed = seed;
@@ -995,9 +984,8 @@ impl ThetaSketchBuilder {
     /// # Examples
     ///
     /// ```
-    /// # use datasketches::theta::ThetaSketch;
-    /// let sketch = ThetaSketch::builder().lg_k(10).build();
-    /// assert_eq!(sketch.lg_k(), 10);
+    /// # use datasketches::theta::ThetaSketchBuilder;
+    /// ThetaSketchBuilder::default().lg_k(10).build();
     /// ```
     pub fn build(self) -> ThetaSketch {
         let table = ThetaHashTable::new(
@@ -1065,7 +1053,7 @@ mod tests {
 
     #[test]
     fn theta_and_compact_theta_equivalent() {
-        let mut exact_theta = ThetaSketch::builder().lg_k(12).build();
+        let mut exact_theta = ThetaSketchBuilder::default().lg_k(12).build();
         for i in 0..2000 {
             exact_theta.update(i);
         }
@@ -1074,7 +1062,7 @@ mod tests {
             assert_theta_and_compact_equivalent_ordered(&exact_theta, ordered);
         }
 
-        let mut estimation_theta = ThetaSketch::builder().lg_k(5).build();
+        let mut estimation_theta = ThetaSketchBuilder::default().lg_k(5).build();
         for i in 0..5000 {
             estimation_theta.update(i);
         }
@@ -1086,7 +1074,7 @@ mod tests {
 
     #[test]
     fn compact_theta_serialize_deserialize_round_trip_equivalent_to_compact_and_theta() {
-        let mut theta = ThetaSketch::builder().lg_k(5).build();
+        let mut theta = ThetaSketchBuilder::default().lg_k(5).build();
         for i in 0..5000 {
             theta.update(i);
         }
@@ -1102,7 +1090,7 @@ mod tests {
 
     #[test]
     fn compact_theta_serialize_compressed_round_trip_tail_entries() {
-        let mut theta = ThetaSketch::builder().lg_k(12).build();
+        let mut theta = ThetaSketchBuilder::default().lg_k(12).build();
         for i in 0..13 {
             theta.update(i);
         }
@@ -1117,7 +1105,7 @@ mod tests {
 
     #[test]
     fn compact_theta_serialize_compressed_round_trip_more_than_255_entries() {
-        let mut theta = ThetaSketch::builder().lg_k(12).build();
+        let mut theta = ThetaSketchBuilder::default().lg_k(12).build();
         for i in 0..300 {
             theta.update(i);
         }
@@ -1132,7 +1120,7 @@ mod tests {
 
     #[test]
     fn compact_theta_serialize_compressed_round_trip_estimation_mode() {
-        let mut theta = ThetaSketch::builder().lg_k(5).build();
+        let mut theta = ThetaSketchBuilder::default().lg_k(5).build();
         for i in 0..5000 {
             theta.update(i);
         }
@@ -1146,7 +1134,7 @@ mod tests {
 
     #[test]
     fn deserialize_rejects_seed_hash_mismatch() {
-        let mut theta = ThetaSketch::builder().seed(7).build();
+        let mut theta = ThetaSketchBuilder::default().seed(7).build();
         theta.update("apple");
         let bytes = theta.compact(true).serialize();
 
@@ -1157,7 +1145,7 @@ mod tests {
 
     #[test]
     fn deserialize_rejects_invalid_family_id() {
-        let mut theta = ThetaSketch::builder().build();
+        let mut theta = ThetaSketchBuilder::default().build();
         theta.update("apple");
         let mut bytes = theta.compact(true).serialize();
         bytes[2] = 0;
@@ -1169,7 +1157,7 @@ mod tests {
 
     #[test]
     fn deserialize_rejects_unsupported_serial_version() {
-        let mut theta = ThetaSketch::builder().build();
+        let mut theta = ThetaSketchBuilder::default().build();
         theta.update("apple");
         let mut bytes = theta.compact(true).serialize();
         bytes[1] = 99;
@@ -1181,7 +1169,7 @@ mod tests {
 
     #[test]
     fn deserialize_rejects_truncated_payload() {
-        let mut theta = ThetaSketch::builder().lg_k(5).build();
+        let mut theta = ThetaSketchBuilder::default().lg_k(5).build();
         for i in 0..5000 {
             theta.update(i);
         }
diff --git a/datasketches/src/theta/union.rs b/datasketches/src/theta/union.rs
index 06ec617..9bded2e 100644
--- a/datasketches/src/theta/union.rs
+++ b/datasketches/src/theta/union.rs
@@ -41,18 +41,6 @@ impl RawThetaUnionPolicy<ThetaEntry> for NoopUnionPolicy {
 }
 
 impl ThetaUnion {
-    /// Create a new builder for ThetaUnion
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # use datasketches::theta::ThetaUnion;
-    /// let _union = ThetaUnion::builder().lg_k(12).build();
-    /// ```
-    pub fn builder() -> ThetaUnionBuilder {
-        ThetaUnionBuilder::default()
-    }
-
     /// Update this union with a given sketch.
     pub fn update<S: ThetaSketchView>(&mut self, sketch: &S) -> Result<(), Error> {
         self.raw.update(sketch)
@@ -110,8 +98,8 @@ impl ThetaUnionBuilder {
     /// # Examples
     ///
     /// ```
-    /// # use datasketches::theta::ThetaUnion;
-    /// let _union = ThetaUnion::builder().lg_k(12).build();
+    /// # use datasketches::theta::ThetaUnionBuilder;
+    /// ThetaUnionBuilder::default().lg_k(12).build();
     /// ```
     pub fn lg_k(mut self, lg_k: u8) -> Self {
         assert!(
@@ -137,8 +125,10 @@ impl ThetaUnionBuilder {
     /// # Examples
     ///
     /// ```
-    /// # use datasketches::theta::ThetaUnion;
-    /// let _union = ThetaUnion::builder().sampling_probability(0.5).build();
+    /// # use datasketches::theta::ThetaUnionBuilder;
+    /// ThetaUnionBuilder::default()
+    ///     .sampling_probability(0.5)
+    ///     .build();
     /// ```
     pub fn sampling_probability(mut self, p: f32) -> Self {
         assert!(
@@ -154,8 +144,8 @@ impl ThetaUnionBuilder {
     /// # Examples
     ///
     /// ```
-    /// # use datasketches::theta::ThetaUnion;
-    /// let _union = ThetaUnion::builder().seed(7).build();
+    /// # use datasketches::theta::ThetaUnionBuilder;
+    /// ThetaUnionBuilder::default().seed(7).build();
     /// ```
     pub fn seed(mut self, seed: u64) -> Self {
         self.seed = seed;
@@ -167,8 +157,8 @@ impl ThetaUnionBuilder {
     /// # Examples
     ///
     /// ```
-    /// # use datasketches::theta::ThetaUnion;
-    /// let _union = ThetaUnion::builder().lg_k(10).build();
+    /// # use datasketches::theta::ThetaUnionBuilder;
+    /// ThetaUnionBuilder::default().lg_k(10).build();
     /// ```
     pub fn build(self) -> ThetaUnion {
         ThetaUnion {
diff --git a/datasketches/src/tuple/mod.rs b/datasketches/src/tuple/mod.rs
index f76af9e..543e958 100644
--- a/datasketches/src/tuple/mod.rs
+++ b/datasketches/src/tuple/mod.rs
@@ -22,15 +22,17 @@
 //! mechanics (theta screening, resize, rebuild to nominal size k) mirror the Theta sketch, with the
 //! added requirement that colliding keys merge their summaries.
 //!
-//! The behavior of a summary (how to create and update it) is supplied externally through
-//! policy objects ([`SummaryUpdatePolicy`]) rather than being baked into the summary type.
+//! Custom summary behavior is supplied externally through policy objects: [`SummaryPolicy`]
+//! creates summaries, while [`SummaryUpdatePolicy`] folds update values into them. Summaries that
+//! implement `Default` and `AddAssign` can use [`DefaultUpdatePolicy`].
 //!
 //! # Usage
 //!
 //! ```
-//! # use datasketches::tuple::TupleSketch;
-//! let mut sketch = TupleSketch::<u64>::builder().build();
-//! sketch.update("apple", 1);
+//! # use datasketches::tuple::{DefaultUpdatePolicy, TupleSketchBuilder};
+//! let policy = DefaultUpdatePolicy::<u64>::default();
+//! let mut sketch = TupleSketchBuilder::new(policy).build();
+//! sketch.update("apple", 1_u64);
 //! assert!(sketch.estimate() >= 1.0);
 //! ```
 
@@ -41,6 +43,7 @@ mod sketch;
 
 pub use self::hash_table::TupleEntry;
 pub use self::policy::DefaultUpdatePolicy;
+pub use self::policy::SummaryPolicy;
 pub use self::policy::SummaryUpdatePolicy;
 pub use self::serialization::TupleSummaryValue;
 pub use self::sketch::CompactTupleSketch;
diff --git a/datasketches/src/tuple/policy.rs b/datasketches/src/tuple/policy.rs
index 468ffd4..c83eebf 100644
--- a/datasketches/src/tuple/policy.rs
+++ b/datasketches/src/tuple/policy.rs
@@ -15,7 +15,7 @@
 // specific language governing permissions and limitations
 // under the License.
 
-//! Policies describing how summaries are created, updated, and combined.
+//! Policies describing how summaries are created and updated.
 //!
 //! A Tuple sketch keeps a user-defined summary `S` next to every retained key. The behavior of a
 //! summary is supplied externally through policy objects rather than baked into the summary type
@@ -23,54 +23,56 @@
 //! different behaviors and can carry per-instance configuration (such as the number of values in an
 //! array-of-doubles summary).
 
+use std::marker::PhantomData;
 use std::ops::AddAssign;
 
-/// Defines how a summary is created and how update values are folded into it.
-///
-/// This is used by the update tuple sketch. `S` is the stored summary type and `U` is the type of
-/// the update value, which may be a borrowed type such as `&[f64]`.
-pub trait SummaryUpdatePolicy<S, U> {
+/// Defines how summaries are created.
+pub trait SummaryPolicy {
+    /// Summary type retained alongside each key.
+    type Summary;
+
     /// Creates a new summary for a key seen for the first time.
     ///
     /// The summary should be in its identity state; the first update value is folded in separately
-    /// via [`update`](Self::update).
-    fn create(&self) -> S;
+    /// via [`SummaryUpdatePolicy::update`].
+    fn create(&self) -> Self::Summary;
+}
 
+/// Defines how update values are folded into summaries.
+///
+/// A policy may implement this trait for multiple update types. For example, an array policy can
+/// accept slices, vectors, or other containers while retaining a single summary type defined by
+/// [`SummaryPolicy`].
+pub trait SummaryUpdatePolicy<U>: SummaryPolicy {
     /// Folds an update value into an existing summary.
-    fn update(&self, summary: &mut S, value: U);
+    fn update(&self, summary: &mut Self::Summary, value: U);
 }
 
-/// Default update policy for summaries that are default-constructible and additive.
+/// Built-in update policy for additive summaries.
 ///
-/// This is the convenience policy used when no custom policy is supplied, equivalent to C++
-/// `default_tuple_update_policy` (which folds updates with `summary += update`). It is available
-/// for any summary type `S` and update type `U` where `S: Default + AddAssign<U>`.
-#[derive(Debug, Default, Clone, Copy)]
-pub struct DefaultUpdatePolicy(());
+/// The factory determines the summary type and creates its identity state. The policy accepts every
+/// update type `U` for which the summary implements [`AddAssign<U>`].
+#[derive(Default, Debug, Clone, Copy)]
+pub struct DefaultUpdatePolicy<S> {
+    marker: PhantomData<fn() -> S>,
+}
 
-impl<S, U> SummaryUpdatePolicy<S, U> for DefaultUpdatePolicy
+impl<S> SummaryPolicy for DefaultUpdatePolicy<S>
 where
-    S: Default + AddAssign<U>,
+    S: Default,
 {
-    fn create(&self) -> S {
-        S::default()
-    }
+    type Summary = S;
 
-    fn update(&self, summary: &mut S, value: U) {
-        *summary += value;
+    fn create(&self) -> Self::Summary {
+        S::default()
     }
 }
 
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn default_update_policy_update_accumulates() {
-        let policy = DefaultUpdatePolicy::default();
-        let mut summary = 0u64;
-        policy.update(&mut summary, 3);
-        policy.update(&mut summary, 4);
-        assert_eq!(summary, 7);
+impl<S, U> SummaryUpdatePolicy<U> for DefaultUpdatePolicy<S>
+where
+    S: Default + AddAssign<U>,
+{
+    fn update(&self, summary: &mut Self::Summary, value: U) {
+        *summary += value;
     }
 }
diff --git a/datasketches/src/tuple/sketch.rs b/datasketches/src/tuple/sketch.rs
index 78cc6ae..501ebcc 100644
--- a/datasketches/src/tuple/sketch.rs
+++ b/datasketches/src/tuple/sketch.rs
@@ -19,10 +19,10 @@
 //!
 //! This module provides [`TupleSketch`] (mutable) and [`CompactTupleSketch`] (immutable),
 //! the Tuple sketch analogues of the Theta sketch. Each retained key carries a user-defined summary
-//! whose behavior is supplied by a [`SummaryUpdatePolicy`].
+//! created by a [`SummaryPolicy`] and updated through one or more [`SummaryUpdatePolicy`]
+//! implementations.
 
 use std::hash::Hash;
-use std::marker::PhantomData;
 
 use crate::codec::SketchBytes;
 use crate::codec::SketchSlice;
@@ -46,9 +46,12 @@ use crate::thetacommon::constants::MAX_THETA;
 use crate::thetacommon::constants::MIN_LG_K;
 use crate::tuple::hash_table::TupleEntry;
 use crate::tuple::hash_table::TupleHashTable;
-use crate::tuple::policy::DefaultUpdatePolicy;
+use crate::tuple::policy::SummaryPolicy;
 use crate::tuple::policy::SummaryUpdatePolicy;
-use crate::tuple::serialization;
+use crate::tuple::serialization::SERIAL_VERSION;
+use crate::tuple::serialization::SERIAL_VERSION_LEGACY;
+use crate::tuple::serialization::SKETCH_TYPE;
+use crate::tuple::serialization::SKETCH_TYPE_LEGACY;
 use crate::tuple::serialization::TupleSummaryValue;
 
 /// Read-only view for Tuple sketches.
@@ -65,43 +68,35 @@ impl<S, T> TupleSketchView<S> for T where T: RawThetaSketchView<TupleEntry<S>> {
 
 /// Mutable Tuple sketch for building from input data.
 ///
-/// `S` is the summary type retained alongside each key, and `P` is the [`SummaryUpdatePolicy`] that
-/// defines how summaries are created and updated. For additive summaries the default
-/// [`DefaultUpdatePolicy`] is used.
+/// `P` defines how summaries are created. The summary retained alongside each key is
+/// [`P::Summary`](SummaryPolicy::Summary), while each accepted update type is selected by a
+/// [`SummaryUpdatePolicy<U>`] implementation.
 ///
 /// # Examples
 ///
 /// ```
-/// # use datasketches::tuple::TupleSketch;
-/// let mut sketch = TupleSketch::<u64>::builder().build();
+/// # use datasketches::tuple::{DefaultUpdatePolicy, TupleSketchBuilder};
+/// let policy = DefaultUpdatePolicy::<u64>::default();
+/// let mut sketch = TupleSketchBuilder::new(policy).build();
 /// sketch.update("apple", 1);
 /// sketch.update("apple", 1);
 /// assert!(sketch.estimate() >= 1.0);
 /// assert_eq!(sketch.num_retained(), 1);
 /// ```
 #[derive(Debug)]
-pub struct TupleSketch<S, P = DefaultUpdatePolicy> {
-    table: TupleHashTable<S>,
+pub struct TupleSketch<P>
+where
+    P: SummaryPolicy,
+{
+    table: TupleHashTable<P::Summary>,
     policy: P,
 }
 
-impl<S> TupleSketch<S, DefaultUpdatePolicy> {
-    /// Creates a new builder using the default update policy.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # use datasketches::tuple::TupleSketch;
-    /// let sketch = TupleSketch::<u64>::builder().lg_k(12).build();
-    /// assert_eq!(sketch.lg_k(), 12);
-    /// ```
-    pub fn builder() -> TupleSketchBuilder<S, DefaultUpdatePolicy> {
-        TupleSketchBuilder::default()
-    }
-}
-
-impl<S, P> TupleSketch<S, P> {
-    /// Updates the sketch with a key and an update value.
+impl<P> TupleSketch<P>
+where
+    P: SummaryPolicy,
+{
+    /// Updates the sketch with a key and a value accepted by the policy.
     ///
     /// If the key is new, the policy creates a summary and folds in `value`; if the key already
     /// exists, `value` is folded into the retained summary. Updates screened out by theta do not
@@ -110,13 +105,14 @@ impl<S, P> TupleSketch<S, P> {
     /// # Examples
     ///
     /// ```
-    /// # use datasketches::tuple::TupleSketch;
-    /// let mut sketch = TupleSketch::<u64>::builder().build();
+    /// # use datasketches::tuple::{DefaultUpdatePolicy, TupleSketchBuilder};
+    /// let policy = DefaultUpdatePolicy::<u64>::default();
+    /// let mut sketch = TupleSketchBuilder::new(policy).build();
     /// sketch.update(42, 5);
     /// ```
     pub fn update<U>(&mut self, key: impl Hash, value: U)
     where
-        P: SummaryUpdatePolicy<S, U>,
+        P: SummaryUpdatePolicy<U>,
     {
         let policy = &self.policy;
         self.table.try_insert(key, |existing| match existing {
@@ -188,7 +184,7 @@ impl<S, P> TupleSketch<S, P> {
     }
 
     /// Returns an iterator over retained entries as `(hash, &summary)` pairs.
-    pub fn iter(&self) -> impl Iterator<Item = (u64, &S)> + '_ {
+    pub fn iter(&self) -> impl Iterator<Item = (u64, &P::Summary)> + '_ {
         self.table.iter()
     }
 
@@ -221,7 +217,11 @@ impl<S, P> TupleSketch<S, P> {
     }
 }
 
-impl<S: Clone, P> TupleSketch<S, P> {
+impl<P> TupleSketch<P>
+where
+    P: SummaryPolicy,
+    P::Summary: Clone,
+{
     /// Returns this sketch in compact (immutable) form.
     ///
     /// If `ordered` is true, retained entries are sorted by hash in ascending order.
@@ -229,13 +229,14 @@ impl<S: Clone, P> TupleSketch<S, P> {
     /// # Examples
     ///
     /// ```
-    /// # use datasketches::tuple::TupleSketch;
-    /// let mut sketch = TupleSketch::<u64>::builder().build();
+    /// # use datasketches::tuple::{DefaultUpdatePolicy, TupleSketchBuilder};
+    /// let policy = DefaultUpdatePolicy::<u64>::default();
+    /// let mut sketch = TupleSketchBuilder::new(policy).build();
     /// sketch.update("apple", 1);
     /// let compact = sketch.compact(true);
     /// assert_eq!(compact.num_retained(), 1);
     /// ```
-    pub fn compact(&self, ordered: bool) -> CompactTupleSketch<S> {
+    pub fn compact(&self, ordered: bool) -> CompactTupleSketch<P::Summary> {
         let parts = self.table.to_compact_parts(ordered);
         CompactTupleSketch::from_parts(
             parts.entries,
@@ -247,7 +248,11 @@ impl<S: Clone, P> TupleSketch<S, P> {
     }
 }
 
-impl<S: Clone, P> RawThetaSketchView<TupleEntry<S>> for TupleSketch<S, P> {
+impl<P> RawThetaSketchView<TupleEntry<P::Summary>> for TupleSketch<P>
+where
+    P: SummaryPolicy,
+    P::Summary: Clone,
+{
     fn seed_hash(&self) -> u16 {
         self.table.seed_hash()
     }
@@ -264,7 +269,7 @@ impl<S: Clone, P> RawThetaSketchView<TupleEntry<S>> for TupleSketch<S, P> {
         false
     }
 
-    fn iter(&self) -> impl Iterator<Item = TupleEntry<S>> + '_ {
+    fn iter(&self) -> impl Iterator<Item = TupleEntry<P::Summary>> + '_ {
         self.table
             .iter()
             .map(|(hash, summary)| TupleEntry::new(hash, summary.clone()))
@@ -408,8 +413,9 @@ impl<S> CompactTupleSketch<S> {
     /// # Examples
     ///
     /// ```
-    /// # use datasketches::tuple::TupleSketch;
-    /// let mut sketch = TupleSketch::<u64>::builder().build();
+    /// # use datasketches::tuple::{DefaultUpdatePolicy, TupleSketchBuilder};
+    /// let policy = DefaultUpdatePolicy::<u64>::default();
+    /// let mut sketch = TupleSketchBuilder::new(policy).build();
     /// sketch.update("apple", 1);
     /// let bytes = sketch.compact(true).serialize();
     /// assert!(!bytes.is_empty());
@@ -427,9 +433,9 @@ impl<S> CompactTupleSketch<S> {
         let mut bytes = SketchBytes::with_capacity(8 * pre_longs as usize + entries_size);
 
         bytes.write_u8(pre_longs);
-        bytes.write_u8(serialization::SERIAL_VERSION);
+        bytes.write_u8(SERIAL_VERSION);
         bytes.write_u8(Family::TUPLE.id);
-        bytes.write_u8(serialization::SKETCH_TYPE);
+        bytes.write_u8(SKETCH_TYPE);
         bytes.write_u8(0); // unused
 
         let mut flags = FLAGS_IS_READ_ONLY | FLAGS_IS_COMPACT;
@@ -495,22 +501,16 @@ impl<S> CompactTupleSketch<S> {
             Family::TUPLE.min_pre_longs..=Family::TUPLE.max_pre_longs,
             pre_longs,
         )?;
-        if ser_ver != serialization::SERIAL_VERSION
-            && ser_ver != serialization::SERIAL_VERSION_LEGACY
-        {
+        if ser_ver != SERIAL_VERSION && ser_ver != SERIAL_VERSION_LEGACY {
             return Err(Error::deserial(format!(
                 "unsupported serial version: expected {} or {}, got {ser_ver}",
-                serialization::SERIAL_VERSION,
-                serialization::SERIAL_VERSION_LEGACY,
+                SERIAL_VERSION, SERIAL_VERSION_LEGACY,
             )));
         }
-        if sketch_type != serialization::SKETCH_TYPE
-            && sketch_type != serialization::SKETCH_TYPE_LEGACY
-        {
+        if sketch_type != SKETCH_TYPE && sketch_type != SKETCH_TYPE_LEGACY {
             return Err(Error::deserial(format!(
                 "unsupported sketch type: expected {} or {}, got {sketch_type}",
-                serialization::SKETCH_TYPE,
-                serialization::SKETCH_TYPE_LEGACY,
+                SKETCH_TYPE, SKETCH_TYPE_LEGACY,
             )));
         }
 
@@ -594,33 +594,64 @@ impl<S: Clone> RawThetaSketchView<TupleEntry<S>> for CompactTupleSketch<S> {
 
 /// Builder for [`TupleSketch`].
 ///
-/// The summary type `S` is fixed when the builder is created (for example via
-/// `TupleSketch::<u64>::builder()`), and the policy type `P` defaults to
-/// [`DefaultUpdatePolicy`]. Use [`policy`](Self::policy) to supply a custom policy.
+/// Every builder carries a concrete [`SummaryPolicy`]. Use
+/// [`DefaultUpdatePolicy`](crate::tuple::DefaultUpdatePolicy) for default-constructed additive
+/// summaries, or supply a custom policy.
 #[derive(Debug)]
-pub struct TupleSketchBuilder<S, P = DefaultUpdatePolicy> {
+pub struct TupleSketchBuilder<P>
+where
+    P: SummaryPolicy,
+{
     lg_k: u8,
     resize_factor: ResizeFactor,
     sampling_probability: f32,
     seed: u64,
     policy: P,
-    _marker: PhantomData<fn() -> S>,
 }
 
-impl<S> Default for TupleSketchBuilder<S, DefaultUpdatePolicy> {
-    fn default() -> Self {
+impl<P> TupleSketchBuilder<P>
+where
+    P: SummaryPolicy,
+{
+    /// Creates a builder with the given summary policy.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use datasketches::tuple::SummaryPolicy;
+    /// use datasketches::tuple::SummaryUpdatePolicy;
+    /// use datasketches::tuple::TupleSketchBuilder;
+    ///
+    /// struct MaxPolicy;
+    ///
+    /// impl SummaryPolicy for MaxPolicy {
+    ///     type Summary = u64;
+    ///
+    ///     fn create(&self) -> Self::Summary {
+    ///         0
+    ///     }
+    /// }
+    ///
+    /// impl SummaryUpdatePolicy<u64> for MaxPolicy {
+    ///     fn update(&self, summary: &mut Self::Summary, value: u64) {
+    ///         *summary = (*summary).max(value);
+    ///     }
+    /// }
+    ///
+    /// let mut sketch = TupleSketchBuilder::new(MaxPolicy).build();
+    /// sketch.update("k", 3);
+    /// sketch.update("k", 7);
+    /// ```
+    pub fn new(policy: P) -> Self {
         Self {
             lg_k: DEFAULT_LG_K,
             resize_factor: ResizeFactor::X8,
             sampling_probability: 1.0,
             seed: DEFAULT_UPDATE_SEED,
-            policy: DefaultUpdatePolicy::default(),
-            _marker: PhantomData,
+            policy,
         }
     }
-}
 
-impl<S, P> TupleSketchBuilder<S, P> {
     /// Sets lg_k (log2 of the nominal size k).
     ///
     /// # Panics
@@ -661,51 +692,15 @@ impl<S, P> TupleSketchBuilder<S, P> {
         self
     }
 
-    /// Sets a custom update policy, changing the builder's policy type.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use datasketches::tuple::SummaryUpdatePolicy;
-    /// use datasketches::tuple::TupleSketch;
-    ///
-    /// struct MaxPolicy;
-    ///
-    /// impl SummaryUpdatePolicy<u64, u64> for MaxPolicy {
-    ///     fn create(&self) -> u64 {
-    ///         0
-    ///     }
-    ///
-    ///     fn update(&self, summary: &mut u64, value: u64) {
-    ///         *summary = (*summary).max(value);
-    ///     }
-    /// }
-    ///
-    /// let mut sketch = TupleSketch::<u64>::builder().policy(MaxPolicy).build();
-    /// sketch.update("k", 3);
-    /// sketch.update("k", 7);
-    /// ```
-    pub fn policy<P2>(self, policy: P2) -> TupleSketchBuilder<S, P2> {
-        TupleSketchBuilder {
-            lg_k: self.lg_k,
-            resize_factor: self.resize_factor,
-            sampling_probability: self.sampling_probability,
-            seed: self.seed,
-            policy,
-            _marker: PhantomData,
-        }
-    }
-
-    /// Builds the [`TupleSketch`].
-    pub fn build(self) -> TupleSketch<S, P> {
-        let table = TupleHashTable::new(
-            self.lg_k,
-            self.resize_factor,
-            self.sampling_probability,
-            self.seed,
-        );
+    /// Builds a [`TupleSketch`] using the supplied policy.
+    pub fn build(self) -> TupleSketch<P> {
         TupleSketch {
-            table,
+            table: TupleHashTable::new(
+                self.lg_k,
+                self.resize_factor,
+                self.sampling_probability,
+                self.seed,
+            ),
             policy: self.policy,
         }
     }
@@ -715,9 +710,14 @@ impl<S, P> TupleSketchBuilder<S, P> {
 mod tests {
     use super::*;
     use crate::error::ErrorKind;
+    use crate::tuple::policy::DefaultUpdatePolicy;
+    use crate::tuple::policy::SummaryPolicy;
     use crate::tuple::policy::SummaryUpdatePolicy;
 
-    fn sorted_updatable_entries(sketch: &TupleSketch<u64>) -> Vec<(u64, u64)> {
+    fn sorted_updatable_entries<P>(sketch: &TupleSketch<P>) -> Vec<(u64, u64)>
+    where
+        P: SummaryPolicy<Summary = u64>,
+    {
         let mut entries: Vec<(u64, u64)> = sketch.iter().map(|(h, &s)| (h, s)).collect();
         entries.sort_unstable();
         entries
@@ -729,10 +729,12 @@ mod tests {
         entries
     }
 
-    fn assert_updatable_and_compact_equivalent(
-        updatable: &TupleSketch<u64>,
+    fn assert_updatable_and_compact_equivalent<P>(
+        updatable: &TupleSketch<P>,
         compact: &CompactTupleSketch<u64>,
-    ) {
+    ) where
+        P: SummaryPolicy<Summary = u64>,
+    {
         assert_eq!(updatable.is_empty(), compact.is_empty());
         assert_eq!(updatable.is_estimation_mode(), compact.is_estimation_mode());
         assert_eq!(updatable.num_retained(), compact.num_retained());
@@ -747,7 +749,8 @@ mod tests {
 
     #[test]
     fn exact_mode_updatable_and_compact_equivalent() {
-        let mut sketch = TupleSketch::<u64>::builder().lg_k(12).build();
+        let policy = DefaultUpdatePolicy::<u64>::default();
+        let mut sketch = TupleSketchBuilder::new(policy).lg_k(12).build();
         for i in 0..2000 {
             sketch.update(i, 1u64);
         }
@@ -764,7 +767,8 @@ mod tests {
 
     #[test]
     fn estimation_mode_updatable_and_compact_equivalent() {
-        let mut sketch = TupleSketch::<u64>::builder().lg_k(5).build();
+        let policy = DefaultUpdatePolicy::<u64>::default();
+        let mut sketch = TupleSketchBuilder::new(policy).lg_k(5).build();
         for i in 0..5000 {
             sketch.update(i, 1u64);
         }
@@ -778,7 +782,8 @@ mod tests {
 
     #[test]
     fn summaries_accumulate_with_default_policy() {
-        let mut sketch = TupleSketch::<u64>::builder().build();
+        let policy = DefaultUpdatePolicy::<u64>::default();
+        let mut sketch = TupleSketchBuilder::new(policy).build();
         for _ in 0..5 {
             sketch.update("same_key", 2u64);
         }
@@ -792,9 +797,20 @@ mod tests {
         assert_eq!(sorted_compact_entries(&compact)[0].1, 10);
     }
 
+    #[test]
+    fn default_policy_accepts_any_add_assign_rhs() {
+        let policy = DefaultUpdatePolicy::<String>::default();
+        let mut sketch = TupleSketchBuilder::new(policy).build();
+        sketch.update("k", "hello");
+        sketch.update("k", " world");
+
+        assert_eq!(sketch.iter().next().unwrap().1, "hello world");
+    }
+
     #[test]
     fn empty_sketch_is_ordered_and_zero_estimate() {
-        let sketch = TupleSketch::<u64>::builder().build();
+        let policy = DefaultUpdatePolicy::<u64>::default();
+        let sketch = TupleSketchBuilder::new(policy).build();
         assert!(sketch.is_empty());
         assert_eq!(sketch.estimate(), 0.0);
 
@@ -807,7 +823,8 @@ mod tests {
 
     #[test]
     fn bounds_bracket_estimate_in_estimation_mode() {
-        let mut sketch = TupleSketch::<u64>::builder().lg_k(12).build();
+        let policy = DefaultUpdatePolicy::<u64>::default();
+        let mut sketch = TupleSketchBuilder::new(policy).lg_k(12).build();
         for i in 0..10000 {
             sketch.update(i, 1u64);
         }
@@ -821,32 +838,64 @@ mod tests {
     #[derive(Default)]
     struct MaxPolicy;
 
-    impl SummaryUpdatePolicy<u64, u64> for MaxPolicy {
-        fn create(&self) -> u64 {
+    impl SummaryPolicy for MaxPolicy {
+        type Summary = u64;
+
+        fn create(&self) -> Self::Summary {
             0
         }
+    }
 
-        fn update(&self, summary: &mut u64, value: u64) {
+    impl SummaryUpdatePolicy<u64> for MaxPolicy {
+        fn update(&self, summary: &mut Self::Summary, value: u64) {
             *summary = (*summary).max(value);
         }
     }
 
     #[test]
     fn custom_policy_drives_summary_behavior() {
-        let mut sketch = TupleSketch::<u64>::builder().policy(MaxPolicy).build();
+        let mut sketch = TupleSketchBuilder::new(MaxPolicy).build();
         sketch.update("k", 3u64);
         sketch.update("k", 7u64);
         sketch.update("k", 2u64);
 
         assert_eq!(sketch.num_retained(), 1);
-        let entries = sorted_updatable_entries_generic(&sketch);
+        let entries = sorted_updatable_entries(&sketch);
         assert_eq!(entries[0].1, 7);
     }
 
-    fn sorted_updatable_entries_generic<P>(sketch: &TupleSketch<u64, P>) -> Vec<(u64, u64)> {
-        let mut entries: Vec<(u64, u64)> = sketch.iter().map(|(h, &s)| (h, s)).collect();
-        entries.sort_unstable();
-        entries
+    struct ArraySumPolicy {
+        num_values: usize,
+    }
+
+    impl SummaryPolicy for ArraySumPolicy {
+        type Summary = Vec<f64>;
+
+        fn create(&self) -> Self::Summary {
+            vec![0.0; self.num_values]
+        }
+    }
+
+    impl<U> SummaryUpdatePolicy<U> for ArraySumPolicy
+    where
+        U: AsRef<[f64]>,
+    {
+        fn update(&self, summary: &mut Self::Summary, value: U) {
+            let value = value.as_ref();
+            assert_eq!(value.len(), self.num_values);
+            for (summary, value) in summary.iter_mut().zip(value) {
+                *summary += value;
+            }
+        }
+    }
+
+    #[test]
+    fn custom_policy_accepts_multiple_update_representations() {
+        let mut sketch = TupleSketchBuilder::new(ArraySumPolicy { num_values: 2 }).build();
+        sketch.update("k", &[1.0, 2.0]);
+        sketch.update("k", vec![3.0, 4.0]);
+
+        assert_eq!(sketch.iter().next().unwrap().1, &vec![4.0, 6.0]);
     }
 
     fn view_num_retained<V: TupleSketchView<u64>>(view: &V) -> usize {
@@ -863,7 +912,8 @@ mod tests {
 
     #[test]
     fn view_trait_accepts_both_sketch_types() {
-        let mut sketch = TupleSketch::<u64>::builder().build();
+        let policy = DefaultUpdatePolicy::<u64>::default();
+        let mut sketch = TupleSketchBuilder::new(policy).build();
         for i in 0..100 {
             sketch.update(i, 2u64);
         }
@@ -896,7 +946,8 @@ mod tests {
 
     #[test]
     fn serialize_round_trip_exact_mode() {
-        let mut sketch = TupleSketch::<u64>::builder().lg_k(12).build();
+        let policy = DefaultUpdatePolicy::<u64>::default();
+        let mut sketch = TupleSketchBuilder::new(policy).lg_k(12).build();
         for i in 0..2000 {
             sketch.update(i, 1u64);
         }
@@ -907,7 +958,8 @@ mod tests {
 
     #[test]
     fn serialize_round_trip_estimation_mode() {
-        let mut sketch = TupleSketch::<u64>::builder().lg_k(5).build();
+        let policy = DefaultUpdatePolicy::<u64>::default();
+        let mut sketch = TupleSketchBuilder::new(policy).lg_k(5).build();
         for i in 0..5000 {
             sketch.update(i, 3u64);
         }
@@ -919,7 +971,8 @@ mod tests {
 
     #[test]
     fn serialize_round_trip_empty() {
-        let sketch = TupleSketch::<u64>::builder().build();
+        let policy = DefaultUpdatePolicy::<u64>::default();
+        let sketch = TupleSketchBuilder::new(policy).build();
         let compact = sketch.compact(true);
         assert!(compact.is_empty());
         assert_compact_round_trip(&compact);
@@ -927,7 +980,8 @@ mod tests {
 
     #[test]
     fn serialize_round_trip_single_entry() {
-        let mut sketch = TupleSketch::<u64>::builder().build();
+        let policy = DefaultUpdatePolicy::<u64>::default();
+        let mut sketch = TupleSketchBuilder::new(policy).build();
         sketch.update("only", 42u64);
         let compact = sketch.compact(true);
         assert_eq!(compact.num_retained(), 1);
@@ -943,7 +997,8 @@ mod tests {
 
     #[test]
     fn serialize_header_fields_match_tuple_format() {
-        let mut sketch = TupleSketch::<u64>::builder().build();
+        let policy = DefaultUpdatePolicy::<u64>::default();
+        let mut sketch = TupleSketchBuilder::new(policy).build();
         for i in 0..100 {
             sketch.update(i, 1u64);
         }
@@ -956,7 +1011,8 @@ mod tests {
 
     #[test]
     fn serialize_preserves_summaries() {
-        let mut sketch = TupleSketch::<u64>::builder().build();
+        let policy = DefaultUpdatePolicy::<u64>::default();
+        let mut sketch = TupleSketchBuilder::new(policy).build();
         for i in 0..50 {
             sketch.update(i, 1u64);
             sketch.update(i, 1u64); // each summary accumulates to 2
@@ -969,7 +1025,8 @@ mod tests {
 
     #[test]
     fn deserialize_rejects_wrong_family() {
-        let mut sketch = TupleSketch::<u64>::builder().build();
+        let policy = DefaultUpdatePolicy::<u64>::default();
+        let mut sketch = TupleSketchBuilder::new(policy).build();
         for i in 0..10 {
             sketch.update(i, 1u64);
         }
@@ -981,7 +1038,8 @@ mod tests {
 
     #[test]
     fn deserialize_rejects_seed_mismatch() {
-        let mut sketch = TupleSketch::<u64>::builder().build();
+        let policy = DefaultUpdatePolicy::<u64>::default();
+        let mut sketch = TupleSketchBuilder::new(policy).build();
         for i in 0..10 {
             sketch.update(i, 1u64);
         }
@@ -992,7 +1050,8 @@ mod tests {
 
     #[test]
     fn deserialize_rejects_truncated_summary() {
-        let mut sketch = TupleSketch::<u64>::builder().build();
+        let policy = DefaultUpdatePolicy::<u64>::default();
+        let mut sketch = TupleSketchBuilder::new(policy).build();
         for i in 0..100 {
             sketch.update(i, 1u64);
         }
diff --git a/datasketches/tests/cpc_union_test.rs b/datasketches/tests/cpc_union_test.rs
index 5bc3b18..ec2377c 100644
--- a/datasketches/tests/cpc_union_test.rs
+++ b/datasketches/tests/cpc_union_test.rs
@@ -173,11 +173,11 @@ fn test_reduce_k_window() {
 #[test]
 #[should_panic]
 fn test_lg_k_too_small() {
-    let _ = CpcSketch::new(3);
+    CpcSketch::new(3);
 }
 
 #[test]
 #[should_panic]
 fn test_lg_k_too_large() {
-    let _ = CpcSketch::new(27);
+    CpcSketch::new(27);
 }
diff --git a/datasketches/tests/frequencies_update_test.rs b/datasketches/tests/frequencies_update_test.rs
index 792fa9d..746c410 100644
--- a/datasketches/tests/frequencies_update_test.rs
+++ b/datasketches/tests/frequencies_update_test.rs
@@ -535,5 +535,5 @@ fn test_longs_invalid_map_size_panics() {
 #[test]
 #[should_panic(expected = "max_map_size must be power of 2")]
 fn test_items_invalid_map_size_panics() {
-    let _ = FrequentItemsSketch::<String>::new(6);
+    FrequentItemsSketch::<String>::new(6);
 }
diff --git a/datasketches/tests/theta_intersection_test.rs b/datasketches/tests/theta_intersection_test.rs
index bb662b6..aaa5d44 100644
--- a/datasketches/tests/theta_intersection_test.rs
+++ b/datasketches/tests/theta_intersection_test.rs
@@ -20,9 +20,10 @@
 use datasketches::theta::CompactThetaSketch;
 use datasketches::theta::ThetaIntersection;
 use datasketches::theta::ThetaSketch;
+use datasketches::theta::ThetaSketchBuilder;
 
 fn sketch_with_range(start: u64, count: u64) -> ThetaSketch {
-    let mut sketch = ThetaSketch::builder().build();
+    let mut sketch = ThetaSketchBuilder::default().build();
     for i in 0..count {
         sketch.update(start + i);
     }
@@ -31,7 +32,7 @@ fn sketch_with_range(start: u64, count: u64) -> ThetaSketch {
 
 #[test]
 fn test_has_result_state_machine() {
-    let mut a = ThetaSketch::builder().build();
+    let mut a = ThetaSketchBuilder::default().build();
     a.update("x");
 
     let mut i = ThetaIntersection::new_with_default_seed();
@@ -45,18 +46,18 @@ fn test_has_result_state_machine() {
 fn test_result_before_update_panics() {
     let i = ThetaIntersection::new(123);
     let result = std::panic::catch_unwind(|| {
-        let _ = i.to_sketch(true);
+        i.to_sketch(true);
     });
     assert!(result.is_err());
 }
 
 #[test]
 fn test_update_accepts_compact_sketch() {
-    let mut a = ThetaSketch::builder().build();
+    let mut a = ThetaSketchBuilder::default().build();
     a.update("x");
     a.update("y");
 
-    let mut b = ThetaSketch::builder().build();
+    let mut b = ThetaSketchBuilder::default().build();
     b.update("y");
     b.update("z");
 
@@ -68,7 +69,7 @@ fn test_update_accepts_compact_sketch() {
     assert!(r.estimate() == 1.0);
     assert!(r.is_ordered());
 
-    let mut c = ThetaSketch::builder().build();
+    let mut c = ThetaSketchBuilder::default().build();
     c.update("a");
     c.update("b");
     c.update("c");
@@ -82,7 +83,7 @@ fn test_update_accepts_compact_sketch() {
 
 #[test]
 fn test_seed_mismatch_behaviour_for_empty_sketch() {
-    let empty_other_seed = ThetaSketch::builder().seed(2).build();
+    let empty_other_seed = ThetaSketchBuilder::default().seed(2).build();
     let mut i = ThetaIntersection::new(1);
 
     i.update(&empty_other_seed).unwrap();
@@ -93,7 +94,7 @@ fn test_seed_mismatch_behaviour_for_empty_sketch() {
 
 #[test]
 fn test_seed_mismatch_behaviour() {
-    let mut one_other_seed = ThetaSketch::builder().seed(2).build();
+    let mut one_other_seed = ThetaSketchBuilder::default().seed(2).build();
     one_other_seed.update("value");
     let mut i = ThetaIntersection::new(1);
 
@@ -102,9 +103,9 @@ fn test_seed_mismatch_behaviour() {
 
 #[test]
 fn test_terminal_empty_state_ignores_future_updates() {
-    let empty = ThetaSketch::builder().build();
+    let empty = ThetaSketchBuilder::default().build();
 
-    let mut non_empty = ThetaSketch::builder().build();
+    let mut non_empty = ThetaSketchBuilder::default().build();
     non_empty.update("x");
 
     let mut i = ThetaIntersection::new_with_default_seed();
@@ -117,7 +118,7 @@ fn test_terminal_empty_state_ignores_future_updates() {
 
 #[test]
 fn test_to_sketch_unordered_is_not_ordered() {
-    let mut a = ThetaSketch::builder().build();
+    let mut a = ThetaSketchBuilder::default().build();
     for i in 0..64 {
         a.update(i);
     }
@@ -130,7 +131,7 @@ fn test_to_sketch_unordered_is_not_ordered() {
 
 #[test]
 fn test_empty_update_twice() {
-    let empty = ThetaSketch::builder().build();
+    let empty = ThetaSketchBuilder::default().build();
     let mut i = ThetaIntersection::new_with_default_seed();
 
     i.update(&empty).unwrap();
@@ -150,7 +151,9 @@ fn test_empty_update_twice() {
 
 #[test]
 fn test_non_empty_no_retained_keys() {
-    let mut s = ThetaSketch::builder().sampling_probability(0.001).build();
+    let mut s = ThetaSketchBuilder::default()
+        .sampling_probability(0.001)
+        .build();
     s.update(1u64);
 
     let mut i = ThetaIntersection::new_with_default_seed();
@@ -310,7 +313,7 @@ fn test_estimation_disjoint_ordered() {
 
 #[test]
 fn test_seed_mismatch_non_empty_returns_error() {
-    let mut s = ThetaSketch::builder().build();
+    let mut s = ThetaSketchBuilder::default().build();
     s.update(1u64);
 
     let mut i = ThetaIntersection::new(123);
diff --git a/datasketches/tests/theta_sketch_test.rs b/datasketches/tests/theta_sketch_test.rs
index 55664ef..b7d58ba 100644
--- a/datasketches/tests/theta_sketch_test.rs
+++ b/datasketches/tests/theta_sketch_test.rs
@@ -19,11 +19,11 @@
 
 use datasketches::common::NumStdDev;
 use datasketches::hash_value;
-use datasketches::theta::ThetaSketch;
+use datasketches::theta::ThetaSketchBuilder;
 
 #[test]
 fn test_basic_update() {
-    let mut sketch = ThetaSketch::builder().lg_k(12).build();
+    let mut sketch = ThetaSketchBuilder::default().lg_k(12).build();
     assert!(sketch.is_empty());
     assert_eq!(sketch.estimate(), 0.0);
 
@@ -37,7 +37,7 @@ fn test_basic_update() {
 
 #[test]
 fn test_update_various_types() {
-    let mut sketch = ThetaSketch::builder().lg_k(12).build();
+    let mut sketch = ThetaSketchBuilder::default().lg_k(12).build();
 
     sketch.update("string");
     sketch.update(42i64);
@@ -52,7 +52,7 @@ fn test_update_various_types() {
     assert!(!sketch.is_empty());
     assert_eq!(sketch.estimate(), 5.0);
 
-    let mut sketch = ThetaSketch::builder().lg_k(12).build();
+    let mut sketch = ThetaSketchBuilder::default().lg_k(12).build();
 
     sketch.update("string");
     sketch.update(42i64);
@@ -70,7 +70,7 @@ fn test_update_various_types() {
 
 #[test]
 fn test_duplicate_updates() {
-    let mut sketch = ThetaSketch::builder().lg_k(12).build();
+    let mut sketch = ThetaSketchBuilder::default().lg_k(12).build();
 
     for _ in 0..100 {
         sketch.update("same_value");
@@ -81,7 +81,7 @@ fn test_duplicate_updates() {
 
 #[test]
 fn test_theta_reduction() {
-    let mut sketch = ThetaSketch::builder().lg_k(5).build(); // Small k to trigger theta reduction
+    let mut sketch = ThetaSketchBuilder::default().lg_k(5).build(); // Small k to trigger theta reduction
     assert!(!sketch.is_estimation_mode()); // Should be in estimation mode
 
     // Insert many values to trigger theta reduction
@@ -95,7 +95,7 @@ fn test_theta_reduction() {
 
 #[test]
 fn test_trim() {
-    let mut sketch = ThetaSketch::builder().lg_k(5).build();
+    let mut sketch = ThetaSketchBuilder::default().lg_k(5).build();
 
     // Insert many values
     for i in 0..1000 {
@@ -113,7 +113,7 @@ fn test_trim() {
 
 #[test]
 fn test_reset() {
-    let mut sketch = ThetaSketch::builder().lg_k(5).build();
+    let mut sketch = ThetaSketchBuilder::default().lg_k(5).build();
 
     // Insert many values
     for i in 0..1000 {
@@ -136,7 +136,7 @@ fn test_reset() {
 
 #[test]
 fn test_iterator() {
-    let mut sketch = ThetaSketch::builder().lg_k(12).build();
+    let mut sketch = ThetaSketchBuilder::default().lg_k(12).build();
 
     sketch.update("value1");
     sketch.update("value2");
@@ -148,7 +148,7 @@ fn test_iterator() {
 
 #[test]
 fn test_bounds_empty_sketch() {
-    let sketch = ThetaSketch::builder().lg_k(12).build();
+    let sketch = ThetaSketchBuilder::default().lg_k(12).build();
     assert!(sketch.is_empty());
     assert!(!sketch.is_estimation_mode());
     assert_eq!(sketch.theta(), 1.0);
@@ -163,7 +163,7 @@ fn test_bounds_empty_sketch() {
 
 #[test]
 fn test_bounds_exact_mode() {
-    let mut sketch = ThetaSketch::builder().lg_k(12).build();
+    let mut sketch = ThetaSketchBuilder::default().lg_k(12).build();
     for i in 0..2000 {
         sketch.update(i);
     }
@@ -177,7 +177,7 @@ fn test_bounds_exact_mode() {
 
 #[test]
 fn test_bounds_estimation_mode() {
-    let mut sketch = ThetaSketch::builder().lg_k(12).build();
+    let mut sketch = ThetaSketchBuilder::default().lg_k(12).build();
     let n = 10000;
     for i in 0..n {
         sketch.update(i);
@@ -219,7 +219,7 @@ fn test_bounds_estimation_mode() {
 
 #[test]
 fn test_bounds_with_sampling() {
-    let mut sketch = ThetaSketch::builder()
+    let mut sketch = ThetaSketchBuilder::default()
         .lg_k(12)
         .sampling_probability(0.5)
         .build();
@@ -242,7 +242,7 @@ fn test_bounds_with_sampling() {
 
 #[test]
 fn test_bounds_all_num_std_devs() {
-    let mut sketch = ThetaSketch::builder().lg_k(12).build();
+    let mut sketch = ThetaSketchBuilder::default().lg_k(12).build();
     for i in 0..10000 {
         sketch.update(i);
     }
@@ -266,7 +266,7 @@ fn test_bounds_all_num_std_devs() {
 #[test]
 fn test_bounds_empty_estimation_mode() {
     // Create a sketch with sampling probability < 1.0 to force estimation mode
-    let sketch = ThetaSketch::builder()
+    let sketch = ThetaSketchBuilder::default()
         .lg_k(12)
         .sampling_probability(0.1)
         .build();
@@ -284,7 +284,7 @@ fn test_bounds_empty_estimation_mode() {
 fn test_compact_preserves_logical_non_empty_after_screened_update() {
     let screened_value = (0u64..)
         .find(|candidate| {
-            let mut sketch = ThetaSketch::builder()
+            let mut sketch = ThetaSketchBuilder::default()
                 .lg_k(12)
                 .sampling_probability(0.5)
                 .build();
@@ -293,7 +293,7 @@ fn test_compact_preserves_logical_non_empty_after_screened_update() {
         })
         .expect("failed to find a value screened out by the sampling theta");
 
-    let mut sketch = ThetaSketch::builder()
+    let mut sketch = ThetaSketchBuilder::default()
         .lg_k(12)
         .sampling_probability(0.5)
         .build();
diff --git a/datasketches/tests/theta_union_test.rs b/datasketches/tests/theta_union_test.rs
index e6e9160..453af37 100644
--- a/datasketches/tests/theta_union_test.rs
+++ b/datasketches/tests/theta_union_test.rs
@@ -19,10 +19,11 @@
 
 use datasketches::theta::CompactThetaSketch;
 use datasketches::theta::ThetaSketch;
-use datasketches::theta::ThetaUnion;
+use datasketches::theta::ThetaSketchBuilder;
+use datasketches::theta::ThetaUnionBuilder;
 
 fn sketch_with_range(lg_k: u8, start: i64, count: i64) -> ThetaSketch {
-    let mut sketch = ThetaSketch::builder().lg_k(lg_k).build();
+    let mut sketch = ThetaSketchBuilder::default().lg_k(lg_k).build();
     for value in start..start + count {
         sketch.update(value);
     }
@@ -43,8 +44,8 @@ fn assert_estimate_close(sketch: &CompactThetaSketch, expected: f64, tolerance:
 
 #[test]
 fn test_empty_union() {
-    let sketch = ThetaSketch::builder().build();
-    let mut union = ThetaUnion::builder().build();
+    let sketch = ThetaSketchBuilder::default().build();
+    let mut union = ThetaUnionBuilder::default().build();
     let result = union.to_sketch(true);
     assert_eq!(result.num_retained(), 0);
     assert!(result.is_empty());
@@ -59,10 +60,12 @@ fn test_empty_union() {
 
 #[test]
 fn test_non_empty_no_retained_keys() {
-    let mut sketch = ThetaSketch::builder().sampling_probability(0.001).build();
+    let mut sketch = ThetaSketchBuilder::default()
+        .sampling_probability(0.001)
+        .build();
     sketch.update(1u64);
 
-    let mut union = ThetaUnion::builder().build();
+    let mut union = ThetaUnionBuilder::default().build();
     union.update(&sketch).unwrap();
     let result = union.to_sketch(true);
     assert_eq!(result.num_retained(), 0);
@@ -73,17 +76,17 @@ fn test_non_empty_no_retained_keys() {
 
 #[test]
 fn test_exact_mode_half_overlap() {
-    let mut sketch1 = ThetaSketch::builder().build();
+    let mut sketch1 = ThetaSketchBuilder::default().build();
     for value in 0i64..1000i64 {
         sketch1.update(value);
     }
 
-    let mut sketch2 = ThetaSketch::builder().build();
+    let mut sketch2 = ThetaSketchBuilder::default().build();
     for value in 500i64..1500i64 {
         sketch2.update(value);
     }
 
-    let mut union = ThetaUnion::builder().build();
+    let mut union = ThetaUnionBuilder::default().build();
     union.update(&sketch1).unwrap();
     union.update(&sketch2).unwrap();
     let result = union.to_sketch(true);
@@ -100,19 +103,19 @@ fn test_exact_mode_half_overlap() {
 
 #[test]
 fn test_exact_mode_half_overlap_compact() {
-    let mut sketch1 = ThetaSketch::builder().build();
+    let mut sketch1 = ThetaSketchBuilder::default().build();
     for value in 0i64..1000i64 {
         sketch1.update(value);
     }
     let compact1 = CompactThetaSketch::deserialize(&sketch1.compact(true).serialize()).unwrap();
 
-    let mut sketch2 = ThetaSketch::builder().build();
+    let mut sketch2 = ThetaSketchBuilder::default().build();
     for value in 500i64..1500i64 {
         sketch2.update(value);
     }
     let compact2 = CompactThetaSketch::deserialize(&sketch2.compact(true).serialize()).unwrap();
 
-    let mut union = ThetaUnion::builder().build();
+    let mut union = ThetaUnionBuilder::default().build();
     union.update(&compact1).unwrap();
     union.update(&compact2).unwrap();
     let result = union.to_sketch(true);
@@ -123,17 +126,17 @@ fn test_exact_mode_half_overlap_compact() {
 
 #[test]
 fn test_estimation_mode_half_overlap() {
-    let mut sketch1 = ThetaSketch::builder().build();
+    let mut sketch1 = ThetaSketchBuilder::default().build();
     for value in 0i64..10000i64 {
         sketch1.update(value);
     }
 
-    let mut sketch2 = ThetaSketch::builder().build();
+    let mut sketch2 = ThetaSketchBuilder::default().build();
     for value in 5000i64..15000i64 {
         sketch2.update(value);
     }
 
-    let mut union = ThetaUnion::builder().build();
+    let mut union = ThetaUnionBuilder::default().build();
     union.update(&sketch1).unwrap();
     union.update(&sketch2).unwrap();
     let result = union.to_sketch(true);
@@ -150,38 +153,38 @@ fn test_estimation_mode_half_overlap() {
 
 #[test]
 fn test_seed_mismatch() {
-    let mut sketch = ThetaSketch::builder().build();
+    let mut sketch = ThetaSketchBuilder::default().build();
     sketch.update(1u64);
 
-    let mut union = ThetaUnion::builder().seed(123).build();
+    let mut union = ThetaUnionBuilder::default().seed(123).build();
     assert!(union.update(&sketch).is_err());
 }
 
 #[test]
 fn test_larger_k() {
-    let mut sketch1 = ThetaSketch::builder().lg_k(14).build();
+    let mut sketch1 = ThetaSketchBuilder::default().lg_k(14).build();
     for value in 0i64..16384i64 {
         sketch1.update(value);
     }
 
-    let mut sketch2 = ThetaSketch::builder().lg_k(14).build();
+    let mut sketch2 = ThetaSketchBuilder::default().lg_k(14).build();
     for value in 0i64..26384i64 {
         sketch2.update(value);
     }
 
-    let mut sketch3 = ThetaSketch::builder().lg_k(14).build();
+    let mut sketch3 = ThetaSketchBuilder::default().lg_k(14).build();
     for value in 0i64..86384i64 {
         sketch3.update(value);
     }
 
-    let mut union1 = ThetaUnion::builder().lg_k(16).build();
+    let mut union1 = ThetaUnionBuilder::default().lg_k(16).build();
     union1.update(&sketch2).unwrap();
     union1.update(&sketch1).unwrap();
     union1.update(&sketch3).unwrap();
     let result1 = union1.to_sketch(true);
     assert_eq!(result1.estimate(), sketch3.estimate());
 
-    let mut union2 = ThetaUnion::builder().lg_k(16).build();
+    let mut union2 = ThetaUnionBuilder::default().lg_k(16).build();
     union2.update(&sketch1).unwrap();
     union2.update(&sketch3).unwrap();
     union2.update(&sketch2).unwrap();
@@ -196,7 +199,7 @@ fn test_exact_union_no_overlap() {
     let sketch1 = sketch_with_range(lg_k, 0, k / 2);
     let sketch2 = sketch_with_range(lg_k, k / 2, k / 2);
 
-    let mut union = ThetaUnion::builder().lg_k(lg_k).build();
+    let mut union = ThetaUnionBuilder::default().lg_k(lg_k).build();
     union.update(&sketch1).unwrap();
     union.update(&sketch2).unwrap();
 
@@ -213,7 +216,7 @@ fn test_estimation_union_no_overlap() {
     let sketch1 = sketch_with_range(lg_k, 0, 2 * k);
     let sketch2 = sketch_with_range(lg_k, 2 * k, 2 * k);
 
-    let mut union = ThetaUnion::builder().lg_k(lg_k).build();
+    let mut union = ThetaUnionBuilder::default().lg_k(lg_k).build();
     union.update(&sketch1).unwrap();
     union.update(&sketch2).unwrap();
 
@@ -231,7 +234,7 @@ fn test_exact_union_with_overlap() {
     let sketch1 = sketch_with_range(lg_k, 0, k / 2);
     let sketch2 = sketch_with_range(lg_k, 0, k);
 
-    let mut union = ThetaUnion::builder().lg_k(lg_k).build();
+    let mut union = ThetaUnionBuilder::default().lg_k(lg_k).build();
     union.update(&sketch1).unwrap();
     union.update(&sketch2).unwrap();
 
@@ -250,11 +253,11 @@ fn test_ordered_and_unordered_compact_inputs() {
     let compact_ordered = sketch2.compact(true);
     let compact_unordered = sketch2.compact(false);
 
-    let mut ordered_union = ThetaUnion::builder().lg_k(lg_k).build();
+    let mut ordered_union = ThetaUnionBuilder::default().lg_k(lg_k).build();
     ordered_union.update(&sketch1).unwrap();
     ordered_union.update(&compact_ordered).unwrap();
 
-    let mut unordered_union = ThetaUnion::builder().lg_k(lg_k).build();
+    let mut unordered_union = ThetaUnionBuilder::default().lg_k(lg_k).build();
     unordered_union.update(&sketch1).unwrap();
     unordered_union.update(&compact_unordered).unwrap();
 
@@ -274,7 +277,7 @@ fn test_result_ordering_forms_have_same_estimate() {
     let sketch1 = sketch_with_range(12, 0, 8192);
     let sketch2 = sketch_with_range(12, 8192, 1024);
 
-    let mut union = ThetaUnion::builder().lg_k(12).build();
+    let mut union = ThetaUnionBuilder::default().lg_k(12).build();
     union.update(&sketch1).unwrap();
     union.update(&sketch2).unwrap();
 
@@ -295,7 +298,7 @@ fn test_multi_union() {
         (126_797, 26_797),
         (153_594, 26_797),
     ];
-    let mut union = ThetaUnion::builder().lg_k(lg_k).build();
+    let mut union = ThetaUnionBuilder::default().lg_k(lg_k).build();
 
     for (start, count) in ranges {
         let sketch = sketch_with_range(lg_k, start, count);
@@ -312,7 +315,7 @@ fn test_result_does_not_reset_union() {
     let compact1 = sketch_with_range(lg_k, 0, k).compact(true);
     let compact2 = sketch_with_range(lg_k, k, k).compact(true);
 
-    let mut union = ThetaUnion::builder().lg_k(lg_k).build();
+    let mut union = ThetaUnionBuilder::default().lg_k(lg_k).build();
     union.update(&compact1).unwrap();
     union.update(&compact2).unwrap();
     let first = union.to_sketch(true);
@@ -329,7 +332,7 @@ fn test_union_full_overlap() {
     let compact1 = sketch_with_range(lg_k, 0, k).compact(true);
     let compact2 = sketch_with_range(lg_k, 0, k).compact(true);
 
-    let mut union = ThetaUnion::builder().lg_k(lg_k).build();
+    let mut union = ThetaUnionBuilder::default().lg_k(lg_k).build();
     union.update(&compact1).unwrap();
     union.update(&compact2).unwrap();
     let result = union.to_sketch(true);
@@ -352,11 +355,11 @@ fn test_ordered_input_early_stop_matches_unordered_input() {
         let unordered1 = sketch1.compact(false);
         let unordered2 = sketch2.compact(false);
 
-        let mut ordered_union = ThetaUnion::builder().lg_k(lg_k + 1).build();
+        let mut ordered_union = ThetaUnionBuilder::default().lg_k(lg_k + 1).build();
         ordered_union.update(&ordered1).unwrap();
         ordered_union.update(&ordered2).unwrap();
 
-        let mut unordered_union = ThetaUnion::builder().lg_k(lg_k + 1).build();
+        let mut unordered_union = ThetaUnionBuilder::default().lg_k(lg_k + 1).build();
         unordered_union.update(&unordered1).unwrap();
         unordered_union.update(&unordered2).unwrap();
 
@@ -374,7 +377,7 @@ fn test_union_cutback_to_k() {
     let compact1 = sketch_with_range(lg_k, 0, 3 * k).compact(true);
     let compact2 = sketch_with_range(lg_k, 6 * k, 3 * k).compact(true);
 
-    let mut union = ThetaUnion::builder().lg_k(lg_k).build();
+    let mut union = ThetaUnionBuilder::default().lg_k(lg_k).build();
     union.update(&compact1).unwrap();
     union.update(&compact2).unwrap();
     let result = union.to_sketch(true);
@@ -385,23 +388,23 @@ fn test_union_cutback_to_k() {
 
 #[test]
 fn test_union_empty_valid_rules() {
-    let empty1 = ThetaSketch::builder().build().compact(true);
-    let empty2 = ThetaSketch::builder().build().compact(true);
-    let mut one = ThetaSketch::builder().build();
+    let empty1 = ThetaSketchBuilder::default().build().compact(true);
+    let empty2 = ThetaSketchBuilder::default().build().compact(true);
+    let mut one = ThetaSketchBuilder::default().build();
     one.update(1i64);
     let one = one.compact(true);
 
-    let mut empty_union = ThetaUnion::builder().lg_k(5).build();
+    let mut empty_union = ThetaUnionBuilder::default().lg_k(5).build();
     empty_union.update(&empty1).unwrap();
     empty_union.update(&empty2).unwrap();
     assert!(empty_union.to_sketch(true).is_empty());
 
-    let mut left_non_empty_union = ThetaUnion::builder().lg_k(5).build();
+    let mut left_non_empty_union = ThetaUnionBuilder::default().lg_k(5).build();
     left_non_empty_union.update(&one).unwrap();
     left_non_empty_union.update(&empty2).unwrap();
     assert!(!left_non_empty_union.to_sketch(true).is_empty());
 
-    let mut right_non_empty_union = ThetaUnion::builder().lg_k(5).build();
+    let mut right_non_empty_union = ThetaUnionBuilder::default().lg_k(5).build();
     right_non_empty_union.update(&empty1).unwrap();
     right_non_empty_union.update(&one).unwrap();
     assert!(!right_non_empty_union.to_sketch(true).is_empty());
@@ -412,7 +415,7 @@ fn test_trim_to_k() {
     let hi_sketch = sketch_with_range(10, 0, 3749);
     let lo_sketch = sketch_with_range(9, 10_000, 1783);
 
-    let mut union = ThetaUnion::builder().lg_k(10).build();
+    let mut union = ThetaUnionBuilder::default().lg_k(10).build();
     union.update(&hi_sketch).unwrap();
     union.update(&lo_sketch).unwrap();
     let result = union.to_sketch(true);
@@ -423,7 +426,7 @@ fn test_trim_to_k() {
 #[test]
 fn test_builder_lg_k() {
     let sketch = sketch_with_range(10, 0, 1000);
-    let mut union = ThetaUnion::builder().lg_k(10).build();
+    let mut union = ThetaUnionBuilder::default().lg_k(10).build();
     union.update(&sketch).unwrap();
 
     assert_eq!(union.to_sketch(true).estimate(), 1000.0);
@@ -438,7 +441,7 @@ enum CornerSketchState {
 }
 
 fn corner_sketch(state: CornerSketchState, p: f32, value: i64) -> ThetaSketch {
-    let builder = ThetaSketch::builder().lg_k(5);
+    let builder = ThetaSketchBuilder::default().lg_k(5);
     let mut sketch = match state {
         CornerSketchState::Empty | CornerSketchState::Exact => builder.build(),
         CornerSketchState::Estimation | CornerSketchState::Degenerate => {
@@ -653,7 +656,7 @@ fn test_corner_case_union_states() {
         let sketch_a = corner_sketch(state_a, p_a, value_a);
         let sketch_b = corner_sketch(state_b, p_b, value_b);
 
-        let mut union = ThetaUnion::builder().build();
+        let mut union = ThetaUnionBuilder::default().build();
         union.update(&sketch_a).unwrap();
         union.update(&sketch_b).unwrap();
         let result = union.to_sketch(true);
@@ -676,7 +679,7 @@ fn test_corner_case_union_states() {
 
         let compact_a = sketch_a.compact(true);
         let compact_b = sketch_b.compact(true);
-        let mut union = ThetaUnion::builder().build();
+        let mut union = ThetaUnionBuilder::default().build();
         union.update(&compact_a).unwrap();
         union.update(&compact_b).unwrap();
         let compact_result = union.to_sketch(true);
diff --git a/datasketches/tests/tuple_sketch_test.rs b/datasketches/tests/tuple_sketch_test.rs
index 276ed0d..e80b155 100644
--- a/datasketches/tests/tuple_sketch_test.rs
+++ b/datasketches/tests/tuple_sketch_test.rs
@@ -24,11 +24,16 @@
 
 use datasketches::common::NumStdDev;
 use datasketches::hash_value;
-use datasketches::tuple::TupleSketch;
+use datasketches::tuple::DefaultUpdatePolicy;
+use datasketches::tuple::TupleSketchBuilder;
+
+fn builder() -> TupleSketchBuilder<DefaultUpdatePolicy<u64>> {
+    TupleSketchBuilder::new(DefaultUpdatePolicy::<u64>::default())
+}
 
 #[test]
 fn test_basic_update() {
-    let mut sketch = TupleSketch::<u64>::builder().lg_k(12).build();
+    let mut sketch = builder().lg_k(12).build();
     assert!(sketch.is_empty());
     assert_eq!(sketch.estimate(), 0.0);
 
@@ -42,7 +47,7 @@ fn test_basic_update() {
 
 #[test]
 fn test_summary_accumulates_per_key() {
-    let mut sketch = TupleSketch::<u64>::builder().lg_k(12).build();
+    let mut sketch = builder().lg_k(12).build();
     for _ in 0..5 {
         sketch.update("same_key", 2u64);
     }
@@ -54,7 +59,7 @@ fn test_summary_accumulates_per_key() {
 
 #[test]
 fn test_update_various_types() {
-    let mut sketch = TupleSketch::<u64>::builder().lg_k(12).build();
+    let mut sketch = builder().lg_k(12).build();
 
     sketch.update("string", 1u64);
     sketch.update(42i64, 1u64);
@@ -69,7 +74,7 @@ fn test_update_various_types() {
     assert!(!sketch.is_empty());
     assert_eq!(sketch.estimate(), 5.0);
 
-    let mut sketch = TupleSketch::<u64>::builder().lg_k(12).build();
+    let mut sketch = builder().lg_k(12).build();
 
     sketch.update("string", 1u64);
     sketch.update(42i64, 1u64);
@@ -87,7 +92,7 @@ fn test_update_various_types() {
 
 #[test]
 fn test_duplicate_updates() {
-    let mut sketch = TupleSketch::<u64>::builder().lg_k(12).build();
+    let mut sketch = builder().lg_k(12).build();
 
     for _ in 0..100 {
         sketch.update("same_value", 1u64);
@@ -98,7 +103,7 @@ fn test_duplicate_updates() {
 
 #[test]
 fn test_theta_reduction() {
-    let mut sketch = TupleSketch::<u64>::builder().lg_k(5).build(); // Small k to trigger theta reduction
+    let mut sketch = builder().lg_k(5).build(); // Small k to trigger theta reduction
     assert!(!sketch.is_estimation_mode());
 
     // Insert many values to trigger theta reduction
@@ -112,7 +117,7 @@ fn test_theta_reduction() {
 
 #[test]
 fn test_trim() {
-    let mut sketch = TupleSketch::<u64>::builder().lg_k(5).build();
+    let mut sketch = builder().lg_k(5).build();
 
     // Insert many values
     for i in 0..1000 {
@@ -130,7 +135,7 @@ fn test_trim() {
 
 #[test]
 fn test_reset() {
-    let mut sketch = TupleSketch::<u64>::builder().lg_k(5).build();
+    let mut sketch = builder().lg_k(5).build();
 
     // Insert many values
     for i in 0..1000 {
@@ -153,7 +158,7 @@ fn test_reset() {
 
 #[test]
 fn test_iterator() {
-    let mut sketch = TupleSketch::<u64>::builder().lg_k(12).build();
+    let mut sketch = builder().lg_k(12).build();
 
     sketch.update("value1", 1u64);
     sketch.update("value2", 1u64);
@@ -165,7 +170,7 @@ fn test_iterator() {
 
 #[test]
 fn test_bounds_empty_sketch() {
-    let sketch = TupleSketch::<u64>::builder().lg_k(12).build();
+    let sketch = builder().lg_k(12).build();
     assert!(sketch.is_empty());
     assert!(!sketch.is_estimation_mode());
     assert_eq!(sketch.theta(), 1.0);
@@ -180,7 +185,7 @@ fn test_bounds_empty_sketch() {
 
 #[test]
 fn test_bounds_exact_mode() {
-    let mut sketch = TupleSketch::<u64>::builder().lg_k(12).build();
+    let mut sketch = builder().lg_k(12).build();
     for i in 0..2000 {
         sketch.update(i, 1u64);
     }
@@ -194,7 +199,7 @@ fn test_bounds_exact_mode() {
 
 #[test]
 fn test_bounds_estimation_mode() {
-    let mut sketch = TupleSketch::<u64>::builder().lg_k(12).build();
+    let mut sketch = builder().lg_k(12).build();
     let n = 10000;
     for i in 0..n {
         sketch.update(i, 1u64);
@@ -236,10 +241,7 @@ fn test_bounds_estimation_mode() {
 
 #[test]
 fn test_bounds_with_sampling() {
-    let mut sketch = TupleSketch::<u64>::builder()
-        .lg_k(12)
-        .sampling_probability(0.5)
-        .build();
+    let mut sketch = builder().lg_k(12).sampling_probability(0.5).build();
 
     for i in 0..1000 {
         sketch.update(i, 1u64);
@@ -259,7 +261,7 @@ fn test_bounds_with_sampling() {
 
 #[test]
 fn test_bounds_all_num_std_devs() {
-    let mut sketch = TupleSketch::<u64>::builder().lg_k(12).build();
+    let mut sketch = builder().lg_k(12).build();
     for i in 0..10000 {
         sketch.update(i, 1u64);
     }
@@ -281,10 +283,7 @@ fn test_bounds_all_num_std_devs() {
 #[test]
 fn test_bounds_empty_estimation_mode() {
     // Create a sketch with sampling probability < 1.0 to force estimation mode
-    let sketch = TupleSketch::<u64>::builder()
-        .lg_k(12)
-        .sampling_probability(0.1)
-        .build();
+    let sketch = builder().lg_k(12).sampling_probability(0.1).build();
 
     // The sketch is empty but theta < 1.0, so it's in estimation mode.
     // When empty, both bounds should return 0.0 (matching the Java/Theta behavior).
@@ -299,19 +298,13 @@ fn test_bounds_empty_estimation_mode() {
 fn test_compact_preserves_logical_non_empty_after_screened_update() {
     let screened_value = (0u64..)
         .find(|candidate| {
-            let mut sketch = TupleSketch::<u64>::builder()
-                .lg_k(12)
-                .sampling_probability(0.5)
-                .build();
+            let mut sketch = builder().lg_k(12).sampling_probability(0.5).build();
             sketch.update(*candidate, 1u64);
             !sketch.is_empty() && sketch.num_retained() == 0
         })
         .expect("failed to find a value screened out by the sampling theta");
 
-    let mut sketch = TupleSketch::<u64>::builder()
-        .lg_k(12)
-        .sampling_probability(0.5)
-        .build();
+    let mut sketch = builder().lg_k(12).sampling_probability(0.5).build();
     sketch.update(screened_value, 1u64);
 
     assert!(!sketch.is_empty());


---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@datasketches.apache.org
For additional commands, e-mail: commits-help@datasketches.apache.org