correct the correction in the docs

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "tinyset"
-version = "0.4.5"
+version = "0.4.6"
 authors = ["David Roundy <[email protected]>"]
 
 description = "Size-optimized sets"

src/lib.rs

@@ -26,9 +26,11 @@
 //!
 //! All of these set types will do no heap allocation for small sets of
 //! small elements.  Small sets occupy the same space as a single
-//! pointer, typically 64 bits.  In these 64 bits, you can store up to
-//! 61 elements if the elements are sufficiently small (29 elements on
-//! 32-bit architectures).  For larger numbers, you can store progressively
+//! pointer, typically 64 bits.  In these 64 bits (or 32 bits), you can
+//! store up to
+//! seven elements if the elements are sufficiently small and not too
+//! widely spaced.  For larger numbers and more widely spaced numbers,
+//! you can store progressively
 //! fewer elements without doing a heap allocation.  When it does require
 //! a heap allocation, tinyset is still far more compact than a `HashSet`,
 //! particularly when the elements themselves are small.

src/setu64.rs

@@ -1578,6 +1578,13 @@ mod tests {
         collect_size_is(&[255,260,265,270,275,280,285], 8);
         collect_size_is(&[1000,1002,1004,1006,1008,1009,1010], 8);
 
+        incremental_size_le(& (0..7).collect::<Vec<_>>(), 8);
+        incremental_size_le(& (10..10+7).collect::<Vec<_>>(), 8);
+        incremental_size_le(& (100..100+7).collect::<Vec<_>>(), 8);
+        incremental_size_le(& (1000..1000+7).collect::<Vec<_>>(), 8);
+        incremental_size_le(& (10000..10000+7).collect::<Vec<_>>(), 8);
+        incremental_size_le(& (100000..100000+7).collect::<Vec<_>>(), 8);
+
         incremental_size_le(& (1..30).collect::<Vec<_>>(), 40);
         incremental_size_le(& (1..60).collect::<Vec<_>>(), 40);