Crate slice_group_by[−][src]
Expand description
Crate slice-group-by is a library for efficiently iterating on a slice by groups defined by
a function that specifies if two elements are in the same group.
Example: Linear Searched Immutable Groups
You will only need to define a function that returns true if two elements are in the same group.
The LinearGroupBy iterator will always gives contiguous elements to the predicate function.
use slice_group_by::GroupBy;
let slice = &[1, 1, 1, 3, 3, 2, 2, 2];
let mut iter = slice.linear_group_by_key(|x| -x);
assert_eq!(iter.next(), Some(&[1, 1, 1][..]));
assert_eq!(iter.next(), Some(&[3, 3][..]));
assert_eq!(iter.next(), Some(&[2, 2, 2][..]));
assert_eq!(iter.next(), None);Example: Linear Searched Immutable Str Slices
You will only need to define a function that returns true if two char are in the same group.
The LinearStrGroupBy iterator will always gives contiguous char to the predicate function.
use slice_group_by::StrGroupBy;
let string = "aaaabbbbb饰饰cccc";
let mut iter = string.linear_group_by(|a, b| a == b);
assert_eq!(iter.next(), Some("aaaa"));
assert_eq!(iter.next(), Some("bbbbb"));
assert_eq!(iter.next(), Some("饰饰"));
assert_eq!(iter.next(), Some("cccc"));
assert_eq!(iter.next(), None);Example: Binary Searched Mutable Groups
It is also possible to get mutable non overlapping groups of a slice.
The BinaryGroupBy/Mut and ExponentialGroupBy/Mut iterators will not necessarily
gives contiguous elements to the predicate function. The predicate function should implement
an order consistent with the sort order of the slice.
use slice_group_by::GroupByMut;
let slice = &mut [1, 1, 1, 2, 2, 2, 3, 3];
let mut iter = slice.binary_group_by_mut(|a, b| a == b);
assert_eq!(iter.next(), Some(&mut [1, 1, 1][..]));
assert_eq!(iter.next(), Some(&mut [2, 2, 2][..]));
assert_eq!(iter.next(), Some(&mut [3, 3][..]));
assert_eq!(iter.next(), None);Example: Exponential Searched Mutable Groups starting from the End
It is also possible to get mutable non overlapping groups of a slice even starting from the end of it.
use slice_group_by::GroupByMut;
let slice = &mut [1, 1, 1, 2, 2, 2, 3, 3];
let mut iter = slice.exponential_group_by_mut(|a, b| a == b).rev();
assert_eq!(iter.next(), Some(&mut [3, 3][..]));
assert_eq!(iter.next(), Some(&mut [2, 2, 2][..]));
assert_eq!(iter.next(), Some(&mut [1, 1, 1][..]));
assert_eq!(iter.next(), None);Structs
An iterator that will return non-overlapping groups of equal elements, according to
the PartialEq::eq function in the slice using binary search.
An iterator that will return non-overlapping groups in the slice using binary search.
An iterator that will return non-overlapping groups in the slice using binary search.
An iterator that will return non-overlapping mutable groups in the slice using binary search.
An iterator that will return non-overlapping mutable groups in the slice using binary search.
An iterator that will return non-overlapping mutable groups of equal elements, according to
the PartialEq::eq function in the slice using binary search.
An iterator that will return non-overlapping groups of equal elements, according to
the PartialEq::eq function in the slice using exponential search.
An iterator that will reutrn non-overlapping groups in the slice using exponential search.
An iterator that will reutrn non-overlapping groups in the slice using exponential search.
An iterator that will reutrn non-overlapping mutable groups in the slice using exponential search.
An iterator that will reutrn non-overlapping mutable groups in the slice using exponential search.
An iterator that will return non-overlapping mutable groups of equal elements, according to
the PartialEq::eq function in the slice using exponential search.
An iterator that will return non-overlapping groups of equal elements in the slice using linear/sequential search.
An iterator that will return non-overlapping groups of equal elements in the slice using linear/sequential search.
An iterator that will return non-overlapping mutable groups in the slice using linear/sequential search.
An iterator that will return non-overlapping mutable groups of equal elements in the slice using linear/sequential search.
An iterator that will return non-overlapping groups of equal char
in the str using linear/sequential search.
An iterator that will return non-overlapping groups in the str
using linear/sequential search.
An iterator that will return non-overlapping groups in the str
using linear/sequential search.
An iterator that will return non-overlapping mutable groups in the str
using linear/sequential search.
An iterator that will return non-overlapping mutable groups in the str
using linear/sequential search.
An iterator that will return non-overlapping mutable groups of equal char
in the str using linear/sequential search.
Traits
A convenient trait to construct an iterator returning non-overlapping groups defined by a predicate.
A convenient trait to construct an iterator returning non-overlapping mutable groups defined by a predicate.
A convenient trait to construct an iterator returning non-overlapping str slices
defined by a predicate.
A convenient trait to construct an iterator returning non-overlapping mutable str slices
defined by a predicate.
Functions
Exponential searches this sorted slice for a given element.
Binary searches this sorted slice with a comparator function.
Binary searches this sorted slice with a key extraction function.