diff --git a/src/range_bounds_map.rs b/src/range_bounds_map.rs
index e6693c7..26898bb 100644
--- a/src/range_bounds_map.rs
+++ b/src/range_bounds_map.rs
@@ -166,7 +166,7 @@ pub struct OverlapError;
 /// let mut map =
 /// 	RangeBoundsMap::from_slice_strict([(2..8, true)]).unwrap();
 ///
-/// assert!(range_bounds_map.cut(&(4..=6)).is_err());
+/// assert!(map.cut(&(4..=6)).is_err());
 /// ```
 ///
 /// # Example with `insert_merge_*` functions.
@@ -252,7 +252,7 @@ pub struct OverlapError;
 /// .unwrap();
 ///
 /// assert_eq!(
-/// 	range_bounds_map.insert_merge_touching(
+/// 	map.insert_merge_touching(
 /// 		MultiBounds::Exclusive(4, 6),
 /// 		false
 /// 	),
@@ -303,9 +303,9 @@ where
 	///
 	/// let mut map = RangeBoundsMap::new();
 	///
-	/// assert_eq!(range_bounds_map.len(), 0);
-	/// range_bounds_map.insert_strict(0..1, false).unwrap();
-	/// assert_eq!(range_bounds_map.len(), 1);
+	/// assert_eq!(map.len(), 0);
+	/// map.insert_strict(0..1, false).unwrap();
+	/// assert_eq!(map.len(), 1);
 	/// ```
 	#[trivial]
 	pub fn len(&self) -> usize {
@@ -321,9 +321,9 @@ where
 	///
 	/// let mut map = RangeBoundsMap::new();
 	///
-	/// assert_eq!(range_bounds_map.is_empty(), true);
-	/// range_bounds_map.insert_strict(0..1, false).unwrap();
-	/// assert_eq!(range_bounds_map.is_empty(), false);
+	/// assert_eq!(map.is_empty(), true);
+	/// map.insert_strict(0..1, false).unwrap();
+	/// assert_eq!(map.is_empty(), false);
 	/// ```
 	#[trivial]
 	pub fn is_empty(&self) -> bool {
@@ -350,12 +350,9 @@ where
 	///
 	/// let mut map = RangeBoundsMap::new();
 	///
-	/// assert_eq!(range_bounds_map.insert_strict(5..10, 9), Ok(()));
-	/// assert_eq!(
-	/// 	range_bounds_map.insert_strict(5..10, 2),
-	/// 	Err(OverlapError)
-	/// );
-	/// assert_eq!(range_bounds_map.len(), 1);
+	/// assert_eq!(map.insert_strict(5..10, 9), Ok(()));
+	/// assert_eq!(map.insert_strict(5..10, 2), Err(OverlapError));
+	/// assert_eq!(map.len(), 1);
 	/// ```
 	#[tested]
 	pub fn insert_strict(
@@ -395,13 +392,13 @@ where
 	///
 	/// let mut map = RangeBoundsMap::new();
 	///
-	/// range_bounds_map.insert_strict(5..10, false);
+	/// map.insert_strict(5..10, false);
 	///
-	/// assert_eq!(range_bounds_map.overlaps(&(1..=3)), false);
-	/// assert_eq!(range_bounds_map.overlaps(&(4..5)), false);
+	/// assert_eq!(map.overlaps(&(1..=3)), false);
+	/// assert_eq!(map.overlaps(&(4..5)), false);
 	///
-	/// assert_eq!(range_bounds_map.overlaps(&(4..=5)), true);
-	/// assert_eq!(range_bounds_map.overlaps(&(4..6)), true);
+	/// assert_eq!(map.overlaps(&(4..=5)), true);
+	/// assert_eq!(map.overlaps(&(4..6)), true);
 	/// ```
 	#[trivial]
 	pub fn overlaps<Q>(&self, range_bounds: &Q) -> bool
@@ -433,7 +430,7 @@ where
 	/// ])
 	/// .unwrap();
 	///
-	/// let mut overlapping = range_bounds_map.overlapping(&(2..8));
+	/// let mut overlapping = map.overlapping(&(2..8));
 	///
 	/// assert_eq!(
 	/// 	overlapping.collect::<Vec<_>>(),
@@ -508,9 +505,9 @@ where
 	/// ])
 	/// .unwrap();
 	///
-	/// assert_eq!(range_bounds_map.get_at_point(&3), Some(&false));
-	/// assert_eq!(range_bounds_map.get_at_point(&4), Some(&true));
-	/// assert_eq!(range_bounds_map.get_at_point(&101), None);
+	/// assert_eq!(map.get_at_point(&3), Some(&false));
+	/// assert_eq!(map.get_at_point(&4), Some(&true));
+	/// assert_eq!(map.get_at_point(&101), None);
 	/// ```
 	#[trivial]
 	pub fn get_at_point(&self, point: &I) -> Option<&V> {
@@ -531,9 +528,9 @@ where
 	/// ])
 	/// .unwrap();
 	///
-	/// assert_eq!(range_bounds_map.contains_point(&3), true);
-	/// assert_eq!(range_bounds_map.contains_point(&4), true);
-	/// assert_eq!(range_bounds_map.contains_point(&101), false);
+	/// assert_eq!(map.contains_point(&3), true);
+	/// assert_eq!(map.contains_point(&4), true);
+	/// assert_eq!(map.contains_point(&101), false);
 	/// ```
 	#[trivial]
 	pub fn contains_point(&self, point: &I) -> bool {
@@ -550,11 +547,11 @@ where
 	/// let mut map =
 	/// 	RangeBoundsMap::from_slice_strict([(1..4, false)]).unwrap();
 	///
-	/// if let Some(x) = range_bounds_map.get_at_point_mut(&2) {
+	/// if let Some(x) = map.get_at_point_mut(&2) {
 	/// 	*x = true;
 	/// }
 	///
-	/// assert_eq!(range_bounds_map.get_at_point(&1), Some(&true));
+	/// assert_eq!(map.get_at_point(&1), Some(&true));
 	/// ```
 	#[tested]
 	pub fn get_at_point_mut(&mut self, point: &I) -> Option<&mut V> {
@@ -584,15 +581,9 @@ where
 	/// ])
 	/// .unwrap();
 	///
-	/// assert_eq!(
-	/// 	range_bounds_map.get_entry_at_point(&3),
-	/// 	Some((&(1..4), &false))
-	/// );
-	/// assert_eq!(
-	/// 	range_bounds_map.get_entry_at_point(&4),
-	/// 	Some((&(4..8), &true))
-	/// );
-	/// assert_eq!(range_bounds_map.get_entry_at_point(&101), None);
+	/// assert_eq!(map.get_entry_at_point(&3), Some((&(1..4), &false)));
+	/// assert_eq!(map.get_entry_at_point(&4), Some((&(4..8), &true)));
+	/// assert_eq!(map.get_entry_at_point(&101), None);
 	/// ```
 	#[trivial]
 	pub fn get_entry_at_point(&self, point: &I) -> Option<(&K, &V)> {
@@ -619,7 +610,7 @@ where
 	/// ])
 	/// .unwrap();
 	///
-	/// let mut iter = range_bounds_map.iter();
+	/// let mut iter = map.iter();
 	///
 	/// assert_eq!(iter.next(), Some((&(1..4), &false)));
 	/// assert_eq!(iter.next(), Some((&(4..8), &true)));
@@ -653,17 +644,14 @@ where
 	/// ])
 	/// .unwrap();
 	///
-	/// let mut removed = range_bounds_map.remove_overlapping(&(2..8));
+	/// let mut removed = map.remove_overlapping(&(2..8));
 	///
 	/// assert_eq!(
 	/// 	removed.collect::<Vec<_>>(),
 	/// 	[(1..4, false), (4..8, true)]
 	/// );
 	///
-	/// assert_eq!(
-	/// 	range_bounds_map.iter().collect::<Vec<_>>(),
-	/// 	[(&(8..100), &false)]
-	/// );
+	/// assert_eq!(map.iter().collect::<Vec<_>>(), [(&(8..100), &false)]);
 	/// ```
 	#[tested]
 	pub fn remove_overlapping<Q>(
@@ -917,7 +905,7 @@ where
 	/// ])
 	/// .unwrap();
 	///
-	/// let mut gaps = range_bounds_map.gaps(&(2..));
+	/// let mut gaps = map.gaps(&(2..));
 	///
 	/// assert_eq!(
 	/// 	gaps.collect::<Vec<_>>(),
@@ -1018,7 +1006,7 @@ where
 	/// ])
 	/// .unwrap();
 	///
-	/// let mut gaps_same = range_bounds_map.gaps_same(&(2..));
+	/// let mut gaps_same = map.gaps_same(&(2..));
 	///
 	/// assert_eq!(
 	/// 	gaps_same.collect::<Vec<_>>(),
@@ -1061,15 +1049,9 @@ where
 	/// ])
 	/// .unwrap();
 	///
-	/// assert_eq!(range_bounds_map.contains_range_bounds(&(1..3)), true);
-	/// assert_eq!(
-	/// 	range_bounds_map.contains_range_bounds(&(2..6)),
-	/// 	false
-	/// );
-	/// assert_eq!(
-	/// 	range_bounds_map.contains_range_bounds(&(6..50)),
-	/// 	true
-	/// );
+	/// assert_eq!(map.contains_range_bounds(&(1..3)), true);
+	/// assert_eq!(map.contains_range_bounds(&(2..6)), false);
+	/// assert_eq!(map.contains_range_bounds(&(6..50)), true);
 	/// ```
 	#[trivial]
 	pub fn contains_range_bounds<Q>(&self, range_bounds: &Q) -> bool
@@ -1114,25 +1096,22 @@ where
 	/// 	RangeBoundsMap::from_slice_strict([(1..4, false)]).unwrap();
 	///
 	/// // Touching
-	/// assert_eq!(
-	/// 	range_bounds_map.insert_merge_touching(4..6, true),
-	/// 	Ok(&(1..6))
-	/// );
+	/// assert_eq!(map.insert_merge_touching(4..6, true), Ok(&(1..6)));
 	///
 	/// // Overlapping
 	/// assert_eq!(
-	/// 	range_bounds_map.insert_merge_touching(4..8, false),
+	/// 	map.insert_merge_touching(4..8, false),
 	/// 	Err(OverlapOrTryFromBoundsError::Overlap(OverlapError)),
 	/// );
 	///
 	/// // Neither Touching or Overlapping
 	/// assert_eq!(
-	/// 	range_bounds_map.insert_merge_touching(10..16, false),
+	/// 	map.insert_merge_touching(10..16, false),
 	/// 	Ok(&(10..16))
 	/// );
 	///
 	/// assert_eq!(
-	/// 	range_bounds_map.iter().collect::<Vec<_>>(),
+	/// 	map.iter().collect::<Vec<_>>(),
 	/// 	[(&(1..6), &true), (&(10..16), &false)]
 	/// );
 	/// ```
@@ -1245,24 +1224,21 @@ where
 	///
 	/// // Touching
 	/// assert_eq!(
-	/// 	range_bounds_map.insert_merge_overlapping(-4..1, true),
+	/// 	map.insert_merge_overlapping(-4..1, true),
 	/// 	Ok(&(-4..1))
 	/// );
 	///
 	/// // Overlapping
-	/// assert_eq!(
-	/// 	range_bounds_map.insert_merge_overlapping(2..8, true),
-	/// 	Ok(&(1..8))
-	/// );
+	/// assert_eq!(map.insert_merge_overlapping(2..8, true), Ok(&(1..8)));
 	///
 	/// // Neither Touching or Overlapping
 	/// assert_eq!(
-	/// 	range_bounds_map.insert_merge_overlapping(10..16, false),
+	/// 	map.insert_merge_overlapping(10..16, false),
 	/// 	Ok(&(10..16))
 	/// );
 	///
 	/// assert_eq!(
-	/// 	range_bounds_map.iter().collect::<Vec<_>>(),
+	/// 	map.iter().collect::<Vec<_>>(),
 	/// 	[(&(-4..1), &true), (&(1..8), &true), (&(10..16), &false)]
 	/// );
 	/// ```
@@ -1350,27 +1326,24 @@ where
 	///
 	/// // Touching
 	/// assert_eq!(
-	/// 	range_bounds_map
-	/// 		.insert_merge_touching_or_overlapping(-4..1, true),
+	/// 	map.insert_merge_touching_or_overlapping(-4..1, true),
 	/// 	Ok(&(-4..4))
 	/// );
 	///
 	/// // Overlapping
 	/// assert_eq!(
-	/// 	range_bounds_map
-	/// 		.insert_merge_touching_or_overlapping(2..8, true),
+	/// 	map.insert_merge_touching_or_overlapping(2..8, true),
 	/// 	Ok(&(-4..8))
 	/// );
 	///
 	/// // Neither Touching or Overlapping
 	/// assert_eq!(
-	/// 	range_bounds_map
-	/// 		.insert_merge_touching_or_overlapping(10..16, false),
+	/// 	map.insert_merge_touching_or_overlapping(10..16, false),
 	/// 	Ok(&(10..16))
 	/// );
 	///
 	/// assert_eq!(
-	/// 	range_bounds_map.iter().collect::<Vec<_>>(),
+	/// 	map.iter().collect::<Vec<_>>(),
 	/// 	[(&(-4..8), &true), (&(10..16), &false)]
 	/// );
 	/// ```
@@ -1432,10 +1405,10 @@ where
 	/// let mut map =
 	/// 	RangeBoundsMap::from_slice_strict([(2..8, false)]).unwrap();
 	///
-	/// assert_eq!(range_bounds_map.insert_overwrite(4..6, true), Ok(()));
+	/// assert_eq!(map.insert_overwrite(4..6, true), Ok(()));
 	///
 	/// assert_eq!(
-	/// 	range_bounds_map.iter().collect::<Vec<_>>(),
+	/// 	map.iter().collect::<Vec<_>>(),
 	/// 	[(&(2..4), &false), (&(4..6), &true), (&(6..8), &false)]
 	/// );
 	/// ```
@@ -1469,10 +1442,7 @@ where
 	/// ])
 	/// .unwrap();
 	///
-	/// assert_eq!(
-	/// 	range_bounds_map.first_entry(),
-	/// 	Some((&(1..4), &false))
-	/// );
+	/// assert_eq!(map.first_entry(), Some((&(1..4), &false)));
 	/// ```
 	#[trivial]
 	pub fn first_entry(&self) -> Option<(&K, &V)> {
@@ -1494,7 +1464,7 @@ where
 	/// .unwrap();
 	///
 	/// assert_eq!(
-	/// 	range_bounds_map.last_entry(),
+	/// 	map.last_entry(),
 	/// 	Some((&(8..100), &false))
 	/// );
 	#[trivial]
@@ -1651,8 +1621,7 @@ where
 	/// ])
 	/// .unwrap();
 	///
-	/// let mut overlapping_trimmed =
-	/// 	range_bounds_map.overlapping_trimmed(&(2..20));
+	/// let mut overlapping_trimmed = map.overlapping_trimmed(&(2..20));
 	///
 	/// assert_eq!(
 	/// 	overlapping_trimmed.collect::<Vec<_>>(),
@@ -1714,7 +1683,7 @@ where
 	/// .unwrap();
 	///
 	/// let mut overlapping_trimmed_same =
-	/// 	range_bounds_map.overlapping_trimmed_same(&(2..=20));
+	/// 	map.overlapping_trimmed_same(&(2..=20));
 	///
 	/// assert_eq!(
 	/// 	overlapping_trimmed_same.collect::<Vec<_>>(),
@@ -1744,20 +1713,20 @@ where
 		})
 	}
 
-    /// Allocate a `RangeBoundsMap` and move the given (`RangeBounds`,
-    /// `Value`) pairs from the slice into the map using
-    /// [`RangeBoundsMap::insert_strict()`].
-    ///
+	/// Allocate a `RangeBoundsMap` and move the given (`RangeBounds`,
+	/// `Value`) pairs from the slice into the map using
+	/// [`RangeBoundsMap::insert_strict()`].
+	///
 	/// If any of the given `RangeBounds` overlap any of the other
 	/// `RangeBounds` in the slice, then an [`OverlapError`] is
 	/// returned.
 	///
 	/// # Panics
 	///
-    /// Panics if any of the given `RangeBounds` is an invalid
-    /// `RangeBounds`. See [`Invalid
-    /// RangeBounds`](https://docs.rs/range_bounds_map/latest/range_bounds_map/index.html#Invalid-RangeBounds)
-    /// for more details.
+	/// Panics if any of the given `RangeBounds` is an invalid
+	/// `RangeBounds`. See [`Invalid
+	/// RangeBounds`](https://docs.rs/range_bounds_map/latest/range_bounds_map/index.html#Invalid-RangeBounds)
+	/// for more details.
 	///
 	/// # Examples
 	/// ```
@@ -2605,13 +2574,12 @@ mod tests {
 		assert_gaps(basic(), ii(8, 8), [ii(8, 8)]);
 	}
 	fn assert_gaps<const N: usize>(
-		range_bounds_map: RangeBoundsMap<u8, TestBounds, bool>,
+		map: RangeBoundsMap<u8, TestBounds, bool>,
 		outer_range_bounds: TestBounds,
 		result: [TestBounds; N],
 	) {
 		assert_eq!(
-			range_bounds_map
-				.gaps(&outer_range_bounds)
+			map.gaps(&outer_range_bounds)
 				.map(|(start, end)| (start.cloned(), end.cloned()))
 				.collect::<Vec<_>>(),
 			result
diff --git a/src/range_bounds_set.rs b/src/range_bounds_set.rs
index 94a7c7a..688770d 100644
--- a/src/range_bounds_set.rs
+++ b/src/range_bounds_set.rs
@@ -147,9 +147,9 @@ where
 	///
 	/// let mut set = RangeBoundsSet::new();
 	///
-	/// assert_eq!(range_bounds_set.len(), 0);
-	/// range_bounds_set.insert_strict(0..1).unwrap();
-	/// assert_eq!(range_bounds_set.len(), 1);
+	/// assert_eq!(set.len(), 0);
+	/// set.insert_strict(0..1).unwrap();
+	/// assert_eq!(set.len(), 1);
 	/// ```
 	#[trivial]
 	pub fn len(&self) -> usize {
@@ -165,9 +165,9 @@ where
 	///
 	/// let mut set = RangeBoundsSet::new();
 	///
-	/// assert_eq!(range_bounds_set.is_empty(), true);
-	/// range_bounds_set.insert_strict(0..1).unwrap();
-	/// assert_eq!(range_bounds_set.is_empty(), false);
+	/// assert_eq!(set.is_empty(), true);
+	/// set.insert_strict(0..1).unwrap();
+	/// assert_eq!(set.is_empty(), false);
 	/// ```
 	#[trivial]
 	pub fn is_empty(&self) -> bool {
@@ -194,12 +194,9 @@ where
 	///
 	/// let mut set = RangeBoundsSet::new();
 	///
-	/// assert_eq!(range_bounds_set.insert_strict(5..10), Ok(()));
-	/// assert_eq!(
-	/// 	range_bounds_set.insert_strict(5..10),
-	/// 	Err(OverlapError)
-	/// );
-	/// assert_eq!(range_bounds_set.len(), 1);
+	/// assert_eq!(set.insert_strict(5..10), Ok(()));
+	/// assert_eq!(set.insert_strict(5..10), Err(OverlapError));
+	/// assert_eq!(set.len(), 1);
 	/// ```
 	#[trivial]
 	pub fn insert_strict(
@@ -225,13 +222,13 @@ where
 	///
 	/// let mut set = RangeBoundsSet::new();
 	///
-	/// range_bounds_set.insert_strict(5..10);
+	/// set.insert_strict(5..10);
 	///
-	/// assert_eq!(range_bounds_set.overlaps(&(1..=3)), false);
-	/// assert_eq!(range_bounds_set.overlaps(&(4..5)), false);
+	/// assert_eq!(set.overlaps(&(1..=3)), false);
+	/// assert_eq!(set.overlaps(&(4..5)), false);
 	///
-	/// assert_eq!(range_bounds_set.overlaps(&(4..=5)), true);
-	/// assert_eq!(range_bounds_set.overlaps(&(4..6)), true);
+	/// assert_eq!(set.overlaps(&(4..=5)), true);
+	/// assert_eq!(set.overlaps(&(4..6)), true);
 	/// ```
 	#[trivial]
 	pub fn overlaps<Q>(&self, range_bounds: &Q) -> bool
@@ -258,7 +255,7 @@ where
 	/// let set = RangeBoundsSet::from_slice_strict([1..4, 4..8, 8..100])
 	/// 	.unwrap();
 	///
-	/// let mut overlapping = range_bounds_set.overlapping(&(2..8));
+	/// let mut overlapping = set.overlapping(&(2..8));
 	///
 	/// assert_eq!(
 	/// 	overlapping.collect::<Vec<_>>(),
@@ -286,9 +283,9 @@ where
 	/// let set = RangeBoundsSet::from_slice_strict([1..4, 4..8, 8..100])
 	/// 	.unwrap();
 	///
-	/// assert_eq!(range_bounds_set.get_at_point(&3), Some(&(1..4)));
-	/// assert_eq!(range_bounds_set.get_at_point(&4), Some(&(4..8)));
-	/// assert_eq!(range_bounds_set.get_at_point(&101), None);
+	/// assert_eq!(set.get_at_point(&3), Some(&(1..4)));
+	/// assert_eq!(set.get_at_point(&4), Some(&(4..8)));
+	/// assert_eq!(set.get_at_point(&101), None);
 	/// ```
 	#[trivial]
 	pub fn get_at_point(&self, point: &I) -> Option<&K> {
@@ -305,9 +302,9 @@ where
 	/// let set = RangeBoundsSet::from_slice_strict([1..4, 4..8, 8..100])
 	/// 	.unwrap();
 	///
-	/// assert_eq!(range_bounds_set.contains_point(&3), true);
-	/// assert_eq!(range_bounds_set.contains_point(&4), true);
-	/// assert_eq!(range_bounds_set.contains_point(&101), false);
+	/// assert_eq!(set.contains_point(&3), true);
+	/// assert_eq!(set.contains_point(&4), true);
+	/// assert_eq!(set.contains_point(&101), false);
 	/// ```
 	#[trivial]
 	pub fn contains_point(&self, point: &I) -> bool {
@@ -324,7 +321,7 @@ where
 	/// let set = RangeBoundsSet::from_slice_strict([1..4, 4..8, 8..100])
 	/// 	.unwrap();
 	///
-	/// let mut iter = range_bounds_set.iter();
+	/// let mut iter = set.iter();
 	///
 	/// assert_eq!(iter.next(), Some(&(1..4)));
 	/// assert_eq!(iter.next(), Some(&(4..8)));
@@ -354,14 +351,11 @@ where
 	/// 	RangeBoundsSet::from_slice_strict([1..4, 4..8, 8..100])
 	/// 		.unwrap();
 	///
-	/// let mut removed = range_bounds_set.remove_overlapping(&(2..8));
+	/// let mut removed = set.remove_overlapping(&(2..8));
 	///
 	/// assert_eq!(removed.collect::<Vec<_>>(), [1..4, 4..8]);
 	///
-	/// assert_eq!(
-	/// 	range_bounds_set.iter().collect::<Vec<_>>(),
-	/// 	[&(8..100)]
-	/// );
+	/// assert_eq!(set.iter().collect::<Vec<_>>(), [&(8..100)]);
 	/// ```
 	#[trivial]
 	pub fn remove_overlapping<Q>(
@@ -499,7 +493,7 @@ where
 	/// let set = RangeBoundsSet::from_slice_strict([1..3, 5..7, 9..100])
 	/// 	.unwrap();
 	///
-	/// let mut gaps = range_bounds_set.gaps(&(2..));
+	/// let mut gaps = set.gaps(&(2..));
 	///
 	/// assert_eq!(
 	/// 	gaps.collect::<Vec<_>>(),
@@ -540,7 +534,7 @@ where
 	/// let set = RangeBoundsSet::from_slice_strict([1..3, 5..7, 9..100])
 	/// 	.unwrap();
 	///
-	/// let mut gaps_same = range_bounds_set.gaps_same(&(2..));
+	/// let mut gaps_same = set.gaps_same(&(2..));
 	///
 	/// assert_eq!(
 	/// 	gaps_same.collect::<Vec<_>>(),
@@ -576,15 +570,9 @@ where
 	/// let set = RangeBoundsSet::from_slice_strict([1..3, 5..8, 8..100])
 	/// 	.unwrap();
 	///
-	/// assert_eq!(range_bounds_set.contains_range_bounds(&(1..3)), true);
-	/// assert_eq!(
-	/// 	range_bounds_set.contains_range_bounds(&(2..6)),
-	/// 	false
-	/// );
-	/// assert_eq!(
-	/// 	range_bounds_set.contains_range_bounds(&(6..50)),
-	/// 	true
-	/// );
+	/// assert_eq!(set.contains_range_bounds(&(1..3)), true);
+	/// assert_eq!(set.contains_range_bounds(&(2..6)), false);
+	/// assert_eq!(set.contains_range_bounds(&(6..50)), true);
 	/// ```
 	#[trivial]
 	pub fn contains_range_bounds<Q>(&self, range_bounds: &Q) -> bool
@@ -624,27 +612,18 @@ where
 	/// let mut set = RangeBoundsSet::from_slice_strict([1..4]).unwrap();
 	///
 	/// // Touching
-	/// assert_eq!(
-	/// 	range_bounds_set.insert_merge_touching(4..6),
-	/// 	Ok(&(1..6))
-	/// );
+	/// assert_eq!(set.insert_merge_touching(4..6), Ok(&(1..6)));
 	///
 	/// // Overlapping
 	/// assert_eq!(
-	/// 	range_bounds_set.insert_merge_touching(4..8),
+	/// 	set.insert_merge_touching(4..8),
 	/// 	Err(OverlapOrTryFromBoundsError::Overlap(OverlapError)),
 	/// );
 	///
 	/// // Neither Touching or Overlapping
-	/// assert_eq!(
-	/// 	range_bounds_set.insert_merge_touching(10..16),
-	/// 	Ok(&(10..16))
-	/// );
+	/// assert_eq!(set.insert_merge_touching(10..16), Ok(&(10..16)));
 	///
-	/// assert_eq!(
-	/// 	range_bounds_set.iter().collect::<Vec<_>>(),
-	/// 	[&(1..6), &(10..16)]
-	/// );
+	/// assert_eq!(set.iter().collect::<Vec<_>>(), [&(1..6), &(10..16)]);
 	/// ```
 	#[trivial]
 	pub fn insert_merge_touching(
@@ -681,25 +660,16 @@ where
 	/// let mut set = RangeBoundsSet::from_slice_strict([1..4]).unwrap();
 	///
 	/// // Touching
-	/// assert_eq!(
-	/// 	range_bounds_set.insert_merge_overlapping(-4..1),
-	/// 	Ok(&(-4..1))
-	/// );
+	/// assert_eq!(set.insert_merge_overlapping(-4..1), Ok(&(-4..1)));
 	///
 	/// // Overlapping
-	/// assert_eq!(
-	/// 	range_bounds_set.insert_merge_overlapping(2..8),
-	/// 	Ok(&(1..8))
-	/// );
+	/// assert_eq!(set.insert_merge_overlapping(2..8), Ok(&(1..8)));
 	///
 	/// // Neither Touching or Overlapping
-	/// assert_eq!(
-	/// 	range_bounds_set.insert_merge_overlapping(10..16),
-	/// 	Ok(&(10..16))
-	/// );
+	/// assert_eq!(set.insert_merge_overlapping(10..16), Ok(&(10..16)));
 	///
 	/// assert_eq!(
-	/// 	range_bounds_set.iter().collect::<Vec<_>>(),
+	/// 	set.iter().collect::<Vec<_>>(),
 	/// 	[&(-4..1), &(1..8), &(10..16)]
 	/// );
 	/// ```
@@ -739,26 +709,23 @@ where
 	///
 	/// // Touching
 	/// assert_eq!(
-	/// 	range_bounds_set.insert_merge_touching_or_overlapping(-4..1),
+	/// 	set.insert_merge_touching_or_overlapping(-4..1),
 	/// 	Ok(&(-4..4))
 	/// );
 	///
 	/// // Overlapping
 	/// assert_eq!(
-	/// 	range_bounds_set.insert_merge_touching_or_overlapping(2..8),
+	/// 	set.insert_merge_touching_or_overlapping(2..8),
 	/// 	Ok(&(-4..8))
 	/// );
 	///
 	/// // Neither Touching or Overlapping
 	/// assert_eq!(
-	/// 	range_bounds_set.insert_merge_touching_or_overlapping(10..16),
+	/// 	set.insert_merge_touching_or_overlapping(10..16),
 	/// 	Ok(&(10..16))
 	/// );
 	///
-	/// assert_eq!(
-	/// 	range_bounds_set.iter().collect::<Vec<_>>(),
-	/// 	[&(-4..8), &(10..16)]
-	/// );
+	/// assert_eq!(set.iter().collect::<Vec<_>>(), [&(-4..8), &(10..16)]);
 	/// ```
 	#[trivial]
 	pub fn insert_merge_touching_or_overlapping(
@@ -795,10 +762,10 @@ where
 	///
 	/// let mut set = RangeBoundsSet::from_slice_strict([2..8]).unwrap();
 	///
-	/// assert_eq!(range_bounds_set.insert_overwrite(4..6), Ok(()));
+	/// assert_eq!(set.insert_overwrite(4..6), Ok(()));
 	///
 	/// assert_eq!(
-	/// 	range_bounds_set.iter().collect::<Vec<_>>(),
+	/// 	set.iter().collect::<Vec<_>>(),
 	/// 	[&(2..4), &(4..6), &(6..8)]
 	/// );
 	/// ```
@@ -822,7 +789,7 @@ where
 	/// let set = RangeBoundsSet::from_slice_strict([1..4, 4..8, 8..100])
 	/// 	.unwrap();
 	///
-	/// assert_eq!(range_bounds_set.first(), Some(&(1..4)));
+	/// assert_eq!(set.first(), Some(&(1..4)));
 	/// ```
 	#[trivial]
 	pub fn first(&self) -> Option<&K> {
@@ -838,7 +805,7 @@ where
 	/// let set = RangeBoundsSet::from_slice_strict([1..4, 4..8, 8..100])
 	/// 	.unwrap();
 	///
-	/// assert_eq!(range_bounds_set.last(), Some(&(8..100)));
+	/// assert_eq!(set.last(), Some(&(8..100)));
 	/// ```
 	#[trivial]
 	pub fn last(&self) -> Option<&K> {
@@ -959,8 +926,7 @@ where
 	/// let set = RangeBoundsSet::from_slice_strict([1..4, 4..8, 8..100])
 	/// 	.unwrap();
 	///
-	/// let mut overlapping_trimmed =
-	/// 	range_bounds_set.overlapping_trimmed(&(2..20));
+	/// let mut overlapping_trimmed = set.overlapping_trimmed(&(2..20));
 	///
 	/// assert_eq!(
 	/// 	overlapping_trimmed.collect::<Vec<_>>(),
@@ -1001,7 +967,7 @@ where
 	/// 	.unwrap();
 	///
 	/// let mut overlapping_trimmed_same =
-	/// 	range_bounds_set.overlapping_trimmed_same(&(2..=20));
+	/// 	set.overlapping_trimmed_same(&(2..=20));
 	///
 	/// assert_eq!(
 	/// 	overlapping_trimmed_same.collect::<Vec<_>>(),
diff --git a/todo.md b/todo.md
index 04ac732..40de9f0 100644
--- a/todo.md
+++ b/todo.md
@@ -20,6 +20,10 @@
 
 - replace `RangeBounds` with `K` where applicatble in docs
 - replace rust types URL links with direct rust links
+- normalize the description of the project beteen:
+  - the first line of the crate levele docs/readme
+  - the description meta-data section on github
+  - the descriptio meta-data field in the Cargo.toml
 
 # features