From f73f53c89668cc05217f78227b31b825889233d3 Mon Sep 17 00:00:00 2001 From: ripytide Date: Fri, 31 Mar 2023 20:19:37 +0100 Subject: [PATCH] switched all doc tests to use new ::from_slice_strict() method --- src/lib.rs | 2 +- src/range_bounds_map.rs | 146 ++++++++++++++++++++++++++-------------- src/range_bounds_set.rs | 112 ++++++++++++++++++++---------- 3 files changed, 173 insertions(+), 87 deletions(-) diff --git a/src/lib.rs b/src/lib.rs index 61a1e14..fc4c937 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -76,7 +76,7 @@ along with range_bounds_map. If not, see . //! } //! //! // Next we can create a custom typed RangeBoundsMap -//! let reservation_map = RangeBoundsMap::try_from([ +//! let reservation_map = RangeBoundsMap::from_slice_strict([ //! (Reservation::Finite(10, 20), "Ferris".to_string()), //! (Reservation::Infinite(20), "Corro".to_string()), //! ]) diff --git a/src/range_bounds_map.rs b/src/range_bounds_map.rs index e29843e..45ca107 100644 --- a/src/range_bounds_map.rs +++ b/src/range_bounds_map.rs @@ -50,7 +50,7 @@ use crate::TryFromBounds; /// use range_bounds_map::RangeBoundsMap; /// /// // Make a map of ranges to booleans -/// let mut map = RangeBoundsMap::try_from([ +/// let mut map = RangeBoundsMap::from_slice_strict([ /// (4..8, false), /// (8..18, true), /// (20..100, false), @@ -164,7 +164,7 @@ pub struct OverlapError; /// use range_bounds_map::{RangeBoundsMap, TryFromBoundsError}; /// /// let mut range_bounds_map = -/// RangeBoundsMap::try_from([(2..8, true)]).unwrap(); +/// RangeBoundsMap::from_slice_strict([(2..8, true)]).unwrap(); /// /// assert!(range_bounds_map.cut(&(4..=6)).is_err()); /// ``` @@ -245,7 +245,7 @@ pub struct OverlapError; /// } /// } /// -/// let mut range_bounds_map = RangeBoundsMap::try_from([( +/// let mut range_bounds_map = RangeBoundsMap::from_slice_strict([( /// MultiBounds::Inclusive(2, 4), /// true, /// )]) @@ -426,7 +426,7 @@ where /// ``` /// use range_bounds_map::RangeBoundsMap; /// - /// let range_bounds_map = RangeBoundsMap::try_from([ + /// let range_bounds_map = RangeBoundsMap::from_slice_strict([ /// (1..4, false), /// (4..8, true), /// (8..100, false), @@ -501,7 +501,7 @@ where /// ``` /// use range_bounds_map::RangeBoundsMap; /// - /// let range_bounds_map = RangeBoundsMap::try_from([ + /// let range_bounds_map = RangeBoundsMap::from_slice_strict([ /// (1..4, false), /// (4..8, true), /// (8..100, false), @@ -524,7 +524,7 @@ where /// ``` /// use range_bounds_map::RangeBoundsMap; /// - /// let range_bounds_map = RangeBoundsMap::try_from([ + /// let range_bounds_map = RangeBoundsMap::from_slice_strict([ /// (1..4, false), /// (4..8, true), /// (8..100, false), @@ -548,7 +548,7 @@ where /// use range_bounds_map::RangeBoundsMap; /// /// let mut range_bounds_map = - /// RangeBoundsMap::try_from([(1..4, false)]).unwrap(); + /// RangeBoundsMap::from_slice_strict([(1..4, false)]).unwrap(); /// /// if let Some(x) = range_bounds_map.get_at_point_mut(&2) { /// *x = true; @@ -577,7 +577,7 @@ where /// ``` /// use range_bounds_map::RangeBoundsMap; /// - /// let range_bounds_map = RangeBoundsMap::try_from([ + /// let range_bounds_map = RangeBoundsMap::from_slice_strict([ /// (1..4, false), /// (4..8, true), /// (8..100, false), @@ -612,7 +612,7 @@ where /// ``` /// use range_bounds_map::RangeBoundsMap; /// - /// let range_bounds_map = RangeBoundsMap::try_from([ + /// let range_bounds_map = RangeBoundsMap::from_slice_strict([ /// (1..4, false), /// (4..8, true), /// (8..100, false), @@ -646,7 +646,7 @@ where /// ``` /// use range_bounds_map::RangeBoundsMap; /// - /// let mut range_bounds_map = RangeBoundsMap::try_from([ + /// let mut range_bounds_map = RangeBoundsMap::from_slice_strict([ /// (1..4, false), /// (4..8, true), /// (8..100, false), @@ -719,16 +719,18 @@ where /// /// use range_bounds_map::{RangeBoundsMap, TryFromBoundsError}; /// - /// let mut base = RangeBoundsMap::try_from([ + /// let mut base = RangeBoundsMap::from_slice_strict([ /// (1..4, false), /// (4..8, true), /// (8..100, false), /// ]) /// .unwrap(); /// - /// let after_cut = - /// RangeBoundsMap::try_from([(1..2, false), (40..100, false)]) - /// .unwrap(); + /// let after_cut = RangeBoundsMap::from_slice_strict([ + /// (1..2, false), + /// (40..100, false), + /// ]) + /// .unwrap(); /// /// assert_eq!( /// base.cut(&(2..40)).unwrap().collect::>(), @@ -846,16 +848,18 @@ where /// ``` /// use range_bounds_map::{RangeBoundsMap, TryFromBoundsError}; /// - /// let mut base = RangeBoundsMap::try_from([ + /// let mut base = RangeBoundsMap::from_slice_strict([ /// (1..4, false), /// (4..8, true), /// (8..100, false), /// ]) /// .unwrap(); /// - /// let after_cut = - /// RangeBoundsMap::try_from([(1..2, false), (40..100, false)]) - /// .unwrap(); + /// let after_cut = RangeBoundsMap::from_slice_strict([ + /// (1..2, false), + /// (40..100, false), + /// ]) + /// .unwrap(); /// /// assert_eq!( /// base.cut_same(&(2..40)).unwrap().collect::>(), @@ -906,7 +910,7 @@ where /// /// use range_bounds_map::RangeBoundsMap; /// - /// let range_bounds_map = RangeBoundsMap::try_from([ + /// let range_bounds_map = RangeBoundsMap::from_slice_strict([ /// (1..3, false), /// (5..7, true), /// (9..100, false), @@ -1007,7 +1011,7 @@ where /// /// use range_bounds_map::{RangeBoundsMap, TryFromBoundsError}; /// - /// let range_bounds_map = RangeBoundsMap::try_from([ + /// let range_bounds_map = RangeBoundsMap::from_slice_strict([ /// (1..3, false), /// (5..7, true), /// (9..100, false), @@ -1050,7 +1054,7 @@ where /// ``` /// use range_bounds_map::RangeBoundsMap; /// - /// let range_bounds_map = RangeBoundsMap::try_from([ + /// let range_bounds_map = RangeBoundsMap::from_slice_strict([ /// (1..3, false), /// (5..8, true), /// (8..100, false), @@ -1108,7 +1112,7 @@ where /// }; /// /// let mut range_bounds_map = - /// RangeBoundsMap::try_from([(1..4, false)]).unwrap(); + /// RangeBoundsMap::from_slice_strict([(1..4, false)]).unwrap(); /// /// // Touching /// assert_eq!( @@ -1238,7 +1242,7 @@ where /// use range_bounds_map::RangeBoundsMap; /// /// let mut range_bounds_map = - /// RangeBoundsMap::try_from([(1..4, false)]).unwrap(); + /// RangeBoundsMap::from_slice_strict([(1..4, false)]).unwrap(); /// /// // Touching /// assert_eq!( @@ -1343,7 +1347,7 @@ where /// use range_bounds_map::RangeBoundsMap; /// /// let mut range_bounds_map = - /// RangeBoundsMap::try_from([(1..4, false)]).unwrap(); + /// RangeBoundsMap::from_slice_strict([(1..4, false)]).unwrap(); /// /// // Touching /// assert_eq!( @@ -1427,7 +1431,7 @@ where /// use range_bounds_map::RangeBoundsMap; /// /// let mut range_bounds_map = - /// RangeBoundsMap::try_from([(2..8, false)]).unwrap(); + /// RangeBoundsMap::from_slice_strict([(2..8, false)]).unwrap(); /// /// assert_eq!(range_bounds_map.insert_overwrite(4..6, true), Ok(())); /// @@ -1459,7 +1463,7 @@ where /// ``` /// use range_bounds_map::RangeBoundsMap; /// - /// let range_bounds_map = RangeBoundsMap::try_from([ + /// let range_bounds_map = RangeBoundsMap::from_slice_strict([ /// (1..4, false), /// (4..8, true), /// (8..100, false), @@ -1483,7 +1487,7 @@ where /// ``` /// use range_bounds_map::RangeBoundsMap; /// - /// let range_bounds_map = RangeBoundsMap::try_from([ + /// let range_bounds_map = RangeBoundsMap::from_slice_strict([ /// (1..4, false), /// (4..8, true), /// (8..100, false), @@ -1512,15 +1516,19 @@ where /// ``` /// use range_bounds_map::RangeBoundsMap; /// - /// let mut base = - /// RangeBoundsMap::try_from([(1..4, false), (4..8, true)]) - /// .unwrap(); + /// let mut base = RangeBoundsMap::from_slice_strict([ + /// (1..4, false), + /// (4..8, true), + /// ]) + /// .unwrap(); /// - /// let mut add = - /// RangeBoundsMap::try_from([(10..38, true), (40..42, false)]) - /// .unwrap(); + /// let mut add = RangeBoundsMap::from_slice_strict([ + /// (10..38, true), + /// (40..42, false), + /// ]) + /// .unwrap(); /// - /// let expected = RangeBoundsMap::try_from([ + /// let expected = RangeBoundsMap::from_slice_strict([ /// (1..4, false), /// (4..8, true), /// (10..38, true), @@ -1564,7 +1572,7 @@ where /// /// use range_bounds_map::{RangeBoundsMap, TryFromBoundsError}; /// - /// let mut a = RangeBoundsMap::try_from([ + /// let mut a = RangeBoundsMap::from_slice_strict([ /// (1..2, false), /// (4..8, true), /// (10..16, true), @@ -1637,7 +1645,7 @@ where /// /// use range_bounds_map::RangeBoundsMap; /// - /// let range_bounds_map = RangeBoundsMap::try_from([ + /// let range_bounds_map = RangeBoundsMap::from_slice_strict([ /// (1..4, false), /// (4..8, true), /// (8..100, false), @@ -1699,7 +1707,7 @@ where /// ``` /// use range_bounds_map::{RangeBoundsMap, TryFromBoundsError}; /// - /// let range_bounds_map = RangeBoundsMap::try_from([ + /// let range_bounds_map = RangeBoundsMap::from_slice_strict([ /// (1..4, false), /// (4..8, true), /// (8..100, false), @@ -1736,6 +1744,20 @@ where ) }) } + + /// Allocate a `RangeBoundsMap` and move the given `RangeBounds` + /// in the slice into the map using + /// [`RangeBoundsMap::insert_strict()`]. + #[trivial] + pub fn from_slice_strict( + slice: [(K, V); N], + ) -> Result, OverlapError> { + let mut map = RangeBoundsMap::new(); + for (range_bounds, value) in slice { + map.insert_strict(range_bounds, value); + } + return Ok(map); + } } impl IntoIterator for RangeBoundsMap @@ -2119,7 +2141,7 @@ mod tests { &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]; fn basic() -> RangeBoundsMap { - RangeBoundsMap::try_from([ + RangeBoundsMap::from_slice_strict([ (ui(4), false), (ee(5, 7), true), (ii(7, 7), false), @@ -2129,7 +2151,7 @@ mod tests { } fn special() -> RangeBoundsMap { - RangeBoundsMap::try_from([ + RangeBoundsMap::from_slice_strict([ (mii(4, 6), false), (mee(7, 8), true), (mii(8, 12), false), @@ -2236,7 +2258,10 @@ mod tests { assert_eq!(before.insert_strict(to_insert.0, to_insert.1), result); match after { Some(after) => { - assert_eq!(before, RangeBoundsMap::try_from(after).unwrap()) + assert_eq!( + before, + RangeBoundsMap::from_slice_strict(after).unwrap() + ) } None => assert_eq!(before, clone), } @@ -2343,10 +2368,13 @@ mod tests { let mut range_bounds_map = RangeBoundsMap::new(); range_bounds_map.insert_strict(inside_range, ()).unwrap(); - let result = range_bounds_map + let mut result = RangeBoundsMap::new(); + for resulting_entry in range_bounds_map .overlapping_trimmed(&overlap_range) .map(|(key, value)| (cloned_bounds(key), value.clone())) - .collect::>(); + { + result.insert_strict(resulting_entry.0, resulting_entry.1); + } for i in NUMBERS_DOMAIN { assert_eq!( @@ -2366,10 +2394,13 @@ mod tests { range_bounds_map.insert_strict(inside_range1, ()).unwrap(); range_bounds_map.insert_strict(inside_range2, ()).unwrap(); - let result = range_bounds_map + let mut result = RangeBoundsMap::new(); + for resulting_entry in range_bounds_map .overlapping_trimmed(&overlap_range) .map(|(key, value)| (cloned_bounds(key), value.clone())) - .collect::>(); + { + result.insert_strict(resulting_entry.0, resulting_entry.1); + } for i in NUMBERS_DOMAIN { assert_eq!( @@ -2423,7 +2454,10 @@ mod tests { ); match after { Some(after) => { - assert_eq!(before, RangeBoundsMap::try_from(after).unwrap()) + assert_eq!( + before, + RangeBoundsMap::from_slice_strict(after).unwrap() + ) } None => assert_eq!(before, clone), } @@ -2523,7 +2557,10 @@ mod tests { } match after { Some(after) => { - assert_eq!(before, RangeBoundsMap::try_from(after).unwrap()) + assert_eq!( + before, + RangeBoundsMap::from_slice_strict(after).unwrap() + ) } None => assert_eq!(before, clone), } @@ -2663,7 +2700,10 @@ mod tests { ); match after { Some(after) => { - assert_eq!(before, RangeBoundsMap::try_from(after).unwrap()) + assert_eq!( + before, + RangeBoundsMap::from_slice_strict(after).unwrap() + ) } None => assert_eq!(before, clone), } @@ -2766,7 +2806,10 @@ mod tests { ); match after { Some(after) => { - assert_eq!(before, RangeBoundsMap::try_from(after).unwrap()) + assert_eq!( + before, + RangeBoundsMap::from_slice_strict(after).unwrap() + ) } None => assert_eq!(before, clone), } @@ -2775,7 +2818,7 @@ mod tests { #[test] fn insert_merge_touching_or_overlapping_tests() { assert_insert_merge_touching_or_overlapping( - RangeBoundsMap::try_from([(1..4, false)]).unwrap(), + RangeBoundsMap::from_slice_strict([(1..4, false)]).unwrap(), (-4..1, true), Ok(&(-4..4)), Some([(-4..4, true)]), @@ -2899,7 +2942,10 @@ mod tests { ); match after { Some(after) => { - assert_eq!(before, RangeBoundsMap::try_from(after).unwrap()) + assert_eq!( + before, + RangeBoundsMap::from_slice_strict(after).unwrap() + ) } None => assert_eq!(before, clone), } diff --git a/src/range_bounds_set.rs b/src/range_bounds_set.rs index ae28007..c5ada12 100644 --- a/src/range_bounds_set.rs +++ b/src/range_bounds_set.rs @@ -46,7 +46,8 @@ use crate::{ /// /// // Make a new set /// let mut set = -/// RangeBoundsSet::try_from([4..8, 8..18, 20..100]).unwrap(); +/// RangeBoundsSet::from_slice_strict([4..8, 8..18, 20..100]) +/// .unwrap(); /// /// if set.contains_point(&99) { /// println!("Set contains value at 99 :)"); @@ -256,7 +257,8 @@ where /// use range_bounds_map::RangeBoundsSet; /// /// let range_bounds_set = - /// RangeBoundsSet::try_from([1..4, 4..8, 8..100]).unwrap(); + /// RangeBoundsSet::from_slice_strict([1..4, 4..8, 8..100]) + /// .unwrap(); /// /// let mut overlapping = range_bounds_set.overlapping(&(2..8)); /// @@ -284,7 +286,8 @@ where /// use range_bounds_map::RangeBoundsSet; /// /// let range_bounds_set = - /// RangeBoundsSet::try_from([1..4, 4..8, 8..100]).unwrap(); + /// 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))); @@ -303,7 +306,8 @@ where /// use range_bounds_map::RangeBoundsSet; /// /// let range_bounds_set = - /// RangeBoundsSet::try_from([1..4, 4..8, 8..100]).unwrap(); + /// 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); @@ -322,7 +326,8 @@ where /// use range_bounds_map::RangeBoundsSet; /// /// let range_bounds_set = - /// RangeBoundsSet::try_from([1..4, 4..8, 8..100]).unwrap(); + /// RangeBoundsSet::from_slice_strict([1..4, 4..8, 8..100]) + /// .unwrap(); /// /// let mut iter = range_bounds_set.iter(); /// @@ -351,7 +356,8 @@ where /// use range_bounds_map::RangeBoundsSet; /// /// let mut range_bounds_set = - /// RangeBoundsSet::try_from([1..4, 4..8, 8..100]).unwrap(); + /// RangeBoundsSet::from_slice_strict([1..4, 4..8, 8..100]) + /// .unwrap(); /// /// let mut removed = range_bounds_set.remove_overlapping(&(2..8)); /// @@ -397,10 +403,11 @@ where /// use range_bounds_map::{RangeBoundsSet, TryFromBoundsError}; /// /// let mut base = - /// RangeBoundsSet::try_from([1..4, 4..8, 8..100]).unwrap(); + /// RangeBoundsSet::from_slice_strict([1..4, 4..8, 8..100]) + /// .unwrap(); /// /// let after_cut = - /// RangeBoundsSet::try_from([1..2, 40..100]).unwrap(); + /// RangeBoundsSet::from_slice_strict([1..2, 40..100]).unwrap(); /// /// assert_eq!( /// base.cut(&(2..40)).unwrap().collect::>(), @@ -443,10 +450,11 @@ where /// use range_bounds_map::{RangeBoundsSet, TryFromBoundsError}; /// /// let mut base = - /// RangeBoundsSet::try_from([1..4, 4..8, 8..100]).unwrap(); + /// RangeBoundsSet::from_slice_strict([1..4, 4..8, 8..100]) + /// .unwrap(); /// /// let after_cut = - /// RangeBoundsSet::try_from([1..2, 40..100]).unwrap(); + /// RangeBoundsSet::from_slice_strict([1..2, 40..100]).unwrap(); /// /// assert_eq!( /// base.cut_same(&(2..40)).unwrap().collect::>(), @@ -494,7 +502,8 @@ where /// use range_bounds_map::RangeBoundsSet; /// /// let range_bounds_set = - /// RangeBoundsSet::try_from([1..3, 5..7, 9..100]).unwrap(); + /// RangeBoundsSet::from_slice_strict([1..3, 5..7, 9..100]) + /// .unwrap(); /// /// let mut gaps = range_bounds_set.gaps(&(2..)); /// @@ -535,7 +544,8 @@ where /// use range_bounds_map::{RangeBoundsSet, TryFromBoundsError}; /// /// let range_bounds_set = - /// RangeBoundsSet::try_from([1..3, 5..7, 9..100]).unwrap(); + /// RangeBoundsSet::from_slice_strict([1..3, 5..7, 9..100]) + /// .unwrap(); /// /// let mut gaps_same = range_bounds_set.gaps_same(&(2..)); /// @@ -571,7 +581,8 @@ where /// use range_bounds_map::RangeBoundsSet; /// /// let range_bounds_set = - /// RangeBoundsSet::try_from([1..3, 5..8, 8..100]).unwrap(); + /// RangeBoundsSet::from_slice_strict([1..3, 5..8, 8..100]) + /// .unwrap(); /// /// assert_eq!(range_bounds_set.contains_range_bounds(&(1..3)), true); /// assert_eq!( @@ -619,7 +630,7 @@ where /// }; /// /// let mut range_bounds_set = - /// RangeBoundsSet::try_from([1..4]).unwrap(); + /// RangeBoundsSet::from_slice_strict([1..4]).unwrap(); /// /// // Touching /// assert_eq!( @@ -677,7 +688,7 @@ where /// use range_bounds_map::RangeBoundsSet; /// /// let mut range_bounds_set = - /// RangeBoundsSet::try_from([1..4]).unwrap(); + /// RangeBoundsSet::from_slice_strict([1..4]).unwrap(); /// /// // Touching /// assert_eq!( @@ -735,7 +746,7 @@ where /// use range_bounds_map::RangeBoundsSet; /// /// let mut range_bounds_set = - /// RangeBoundsSet::try_from([1..4]).unwrap(); + /// RangeBoundsSet::from_slice_strict([1..4]).unwrap(); /// /// // Touching /// assert_eq!( @@ -794,7 +805,7 @@ where /// use range_bounds_map::RangeBoundsSet; /// /// let mut range_bounds_set = - /// RangeBoundsSet::try_from([2..8]).unwrap(); + /// RangeBoundsSet::from_slice_strict([2..8]).unwrap(); /// /// assert_eq!(range_bounds_set.insert_overwrite(4..6), Ok(())); /// @@ -821,7 +832,8 @@ where /// use range_bounds_map::RangeBoundsSet; /// /// let range_bounds_set = - /// RangeBoundsSet::try_from([1..4, 4..8, 8..100]).unwrap(); + /// RangeBoundsSet::from_slice_strict([1..4, 4..8, 8..100]) + /// .unwrap(); /// /// assert_eq!(range_bounds_set.first(), Some(&(1..4))); /// ``` @@ -837,7 +849,8 @@ where /// use range_bounds_map::RangeBoundsSet; /// /// let range_bounds_set = - /// RangeBoundsSet::try_from([1..4, 4..8, 8..100]).unwrap(); + /// RangeBoundsSet::from_slice_strict([1..4, 4..8, 8..100]) + /// .unwrap(); /// /// assert_eq!(range_bounds_set.last(), Some(&(8..100))); /// ``` @@ -859,13 +872,19 @@ where /// ``` /// use range_bounds_map::RangeBoundsSet; /// - /// let mut base = RangeBoundsSet::try_from([1..4, 4..8]).unwrap(); + /// let mut base = + /// RangeBoundsSet::from_slice_strict([1..4, 4..8]).unwrap(); /// - /// let mut add = RangeBoundsSet::try_from([10..38, 40..42]).unwrap(); + /// let mut add = + /// RangeBoundsSet::from_slice_strict([10..38, 40..42]).unwrap(); /// - /// let expected = - /// RangeBoundsSet::try_from([1..4, 4..8, 10..38, 40..42]) - /// .unwrap(); + /// let expected = RangeBoundsSet::from_slice_strict([ + /// 1..4, + /// 4..8, + /// 10..38, + /// 40..42, + /// ]) + /// .unwrap(); /// /// assert_eq!(base.append_strict(&mut add), Ok(())); /// assert_eq!(base, expected); @@ -876,12 +895,13 @@ where &mut self, other: &mut RangeBoundsSet, ) -> Result<(), OverlapError> { - self.map.append_strict( - &mut other - .remove_overlapping(&(Bound::Unbounded::, Bound::Unbounded)) - .map(|key| (key, ())) - .collect(), - ) + for range_bounds in + other.remove_overlapping(&(Bound::Unbounded::, Bound::Unbounded)) + { + self.insert_strict(range_bounds)?; + } + + return Ok(()); } /// Splits the set in two at the given `start_bound()`. Returns @@ -899,7 +919,8 @@ where /// use range_bounds_map::{RangeBoundsSet, TryFromBoundsError}; /// /// let mut a = - /// RangeBoundsSet::try_from([1..2, 4..8, 10..16]).unwrap(); + /// RangeBoundsSet::from_slice_strict([1..2, 4..8, 10..16]) + /// .unwrap(); /// /// // Fails because that would leave an Inclusive-Inclusive /// // `RangeBounds` in `a` @@ -921,9 +942,12 @@ where where K: TryFromBounds + Clone, { - self.map - .split_off(start_bound) - .map(|map| map.into_iter().map(first).collect()) + let mut set = RangeBoundsSet::new(); + for (range_bounds, _) in self.map.split_off(start_bound)? { + set.insert_strict(range_bounds).unwrap(); + } + + Ok(set) } /// Similar to [`RangeBoundsSet::overlapping()`] except the @@ -947,7 +971,8 @@ where /// use range_bounds_map::RangeBoundsSet; /// /// let range_bounds_set = - /// RangeBoundsSet::try_from([1..4, 4..8, 8..100]).unwrap(); + /// RangeBoundsSet::from_slice_strict([1..4, 4..8, 8..100]) + /// .unwrap(); /// /// let mut overlapping_trimmed = /// range_bounds_set.overlapping_trimmed(&(2..20)); @@ -988,7 +1013,8 @@ where /// use range_bounds_map::{RangeBoundsSet, TryFromBoundsError}; /// /// let range_bounds_set = - /// RangeBoundsSet::try_from([1..4, 4..8, 8..100]).unwrap(); + /// RangeBoundsSet::from_slice_strict([1..4, 4..8, 8..100]) + /// .unwrap(); /// /// let mut overlapping_trimmed_same = /// range_bounds_set.overlapping_trimmed_same(&(2..=20)); @@ -1014,6 +1040,20 @@ where { self.map.overlapping_trimmed_same(range_bounds).map(first) } + + /// Allocate a `RangeBoundsSet` and move the given `RangeBounds` + /// in the slice into the set using + /// [`RangeBoundsMap::insert_strict()`]. + #[trivial] + pub fn from_slice_strict( + slice: [K; N], + ) -> Result, OverlapError> { + let mut set = RangeBoundsSet::new(); + for range_bounds in slice { + set.insert_strict(range_bounds); + } + return Ok(set); + } } impl IntoIterator for RangeBoundsSet