pub struct Splinter(/* private fields */);Expand description
A compressed bitmap optimized for small, sparse sets of 32-bit unsigned integers.
Splinter is the main owned data structure that can be built incrementally by inserting
values and then optimized for size and query performance. It uses a 256-way tree structure
by decomposing integers into big-endian component bytes, with nodes optimized into four
different storage classes: tree, vec, bitmap, and run.
For zero-copy querying of serialized data, see SplinterRef.
For a clone-on-write wrapper, see crate::CowSplinter.
§Examples
Basic usage:
use splinter_rs::{Splinter, PartitionWrite, PartitionRead, Optimizable};
let mut splinter = Splinter::from_iter([1024, 2048, 123]);
// Check membership
assert!(splinter.contains(1024));
assert!(!splinter.contains(999));
// Get cardinality
assert_eq!(splinter.cardinality(), 3);
// Optimize for better compression, recommended before encoding to bytes.
splinter.optimize();Building from iterator:
use splinter_rs::{Splinter, PartitionRead};
let values = vec![100, 200, 300, 400];
let splinter: Splinter = values.into_iter().collect();
assert_eq!(splinter.cardinality(), 4);
assert!(splinter.contains(200));Implementations§
Source§impl Splinter
impl Splinter
Sourcepub fn encode_to_splinter_ref(&self) -> SplinterRef<Bytes>
pub fn encode_to_splinter_ref(&self) -> SplinterRef<Bytes>
Encodes this splinter into a SplinterRef for zero-copy querying.
This method serializes the splinter data and returns a SplinterRef<Bytes>
that can be used for efficient read-only operations without deserializing
the underlying data structure.
§Examples
use splinter_rs::{Splinter, PartitionWrite, PartitionRead};
let mut splinter = Splinter::from_iter([42, 1337]);
let splinter_ref = splinter.encode_to_splinter_ref();
assert_eq!(splinter_ref.cardinality(), 2);
assert!(splinter_ref.contains(42));Trait Implementations§
Source§impl<B: Deref<Target = [u8]>> BitAndAssign<&CowSplinter<B>> for Splinter
impl<B: Deref<Target = [u8]>> BitAndAssign<&CowSplinter<B>> for Splinter
Source§fn bitand_assign(&mut self, rhs: &CowSplinter<B>)
fn bitand_assign(&mut self, rhs: &CowSplinter<B>)
Performs the
&= operation. Read moreSource§impl BitAndAssign<&Splinter> for Splinter
impl BitAndAssign<&Splinter> for Splinter
Source§fn bitand_assign(&mut self, rhs: &Splinter)
fn bitand_assign(&mut self, rhs: &Splinter)
Performs the
&= operation. Read moreSource§impl<B: Deref<Target = [u8]>> BitAndAssign<&SplinterRef<B>> for Splinter
impl<B: Deref<Target = [u8]>> BitAndAssign<&SplinterRef<B>> for Splinter
Source§fn bitand_assign(&mut self, rhs: &SplinterRef<B>)
fn bitand_assign(&mut self, rhs: &SplinterRef<B>)
Performs the
&= operation. Read moreSource§impl<B: Deref<Target = [u8]>> BitAndAssign<CowSplinter<B>> for Splinter
impl<B: Deref<Target = [u8]>> BitAndAssign<CowSplinter<B>> for Splinter
Source§fn bitand_assign(&mut self, rhs: CowSplinter<B>)
fn bitand_assign(&mut self, rhs: CowSplinter<B>)
Performs the
&= operation. Read moreSource§impl<B: Deref<Target = [u8]>> BitAndAssign<SplinterRef<B>> for Splinter
impl<B: Deref<Target = [u8]>> BitAndAssign<SplinterRef<B>> for Splinter
Source§fn bitand_assign(&mut self, rhs: SplinterRef<B>)
fn bitand_assign(&mut self, rhs: SplinterRef<B>)
Performs the
&= operation. Read moreSource§impl BitAndAssign for Splinter
impl BitAndAssign for Splinter
Source§fn bitand_assign(&mut self, rhs: Splinter)
fn bitand_assign(&mut self, rhs: Splinter)
Performs the
&= operation. Read moreSource§impl<B: Deref<Target = [u8]>> BitOrAssign<&CowSplinter<B>> for Splinter
impl<B: Deref<Target = [u8]>> BitOrAssign<&CowSplinter<B>> for Splinter
Source§fn bitor_assign(&mut self, rhs: &CowSplinter<B>)
fn bitor_assign(&mut self, rhs: &CowSplinter<B>)
Performs the
|= operation. Read moreSource§impl BitOrAssign<&Splinter> for Splinter
impl BitOrAssign<&Splinter> for Splinter
Source§fn bitor_assign(&mut self, rhs: &Splinter)
fn bitor_assign(&mut self, rhs: &Splinter)
Performs the
|= operation. Read moreSource§impl<B: Deref<Target = [u8]>> BitOrAssign<&SplinterRef<B>> for Splinter
impl<B: Deref<Target = [u8]>> BitOrAssign<&SplinterRef<B>> for Splinter
Source§fn bitor_assign(&mut self, rhs: &SplinterRef<B>)
fn bitor_assign(&mut self, rhs: &SplinterRef<B>)
Performs the
|= operation. Read moreSource§impl<B: Deref<Target = [u8]>> BitOrAssign<CowSplinter<B>> for Splinter
impl<B: Deref<Target = [u8]>> BitOrAssign<CowSplinter<B>> for Splinter
Source§fn bitor_assign(&mut self, rhs: CowSplinter<B>)
fn bitor_assign(&mut self, rhs: CowSplinter<B>)
Performs the
|= operation. Read moreSource§impl<B: Deref<Target = [u8]>> BitOrAssign<SplinterRef<B>> for Splinter
impl<B: Deref<Target = [u8]>> BitOrAssign<SplinterRef<B>> for Splinter
Source§fn bitor_assign(&mut self, rhs: SplinterRef<B>)
fn bitor_assign(&mut self, rhs: SplinterRef<B>)
Performs the
|= operation. Read moreSource§impl BitOrAssign for Splinter
impl BitOrAssign for Splinter
Source§fn bitor_assign(&mut self, rhs: Splinter)
fn bitor_assign(&mut self, rhs: Splinter)
Performs the
|= operation. Read moreSource§impl<B: Deref<Target = [u8]>> BitXorAssign<&CowSplinter<B>> for Splinter
impl<B: Deref<Target = [u8]>> BitXorAssign<&CowSplinter<B>> for Splinter
Source§fn bitxor_assign(&mut self, rhs: &CowSplinter<B>)
fn bitxor_assign(&mut self, rhs: &CowSplinter<B>)
Performs the
^= operation. Read moreSource§impl BitXorAssign<&Splinter> for Splinter
impl BitXorAssign<&Splinter> for Splinter
Source§fn bitxor_assign(&mut self, rhs: &Splinter)
fn bitxor_assign(&mut self, rhs: &Splinter)
Performs the
^= operation. Read moreSource§impl<B: Deref<Target = [u8]>> BitXorAssign<&SplinterRef<B>> for Splinter
impl<B: Deref<Target = [u8]>> BitXorAssign<&SplinterRef<B>> for Splinter
Source§fn bitxor_assign(&mut self, rhs: &SplinterRef<B>)
fn bitxor_assign(&mut self, rhs: &SplinterRef<B>)
Performs the
^= operation. Read moreSource§impl<B: Deref<Target = [u8]>> BitXorAssign<CowSplinter<B>> for Splinter
impl<B: Deref<Target = [u8]>> BitXorAssign<CowSplinter<B>> for Splinter
Source§fn bitxor_assign(&mut self, rhs: CowSplinter<B>)
fn bitxor_assign(&mut self, rhs: CowSplinter<B>)
Performs the
^= operation. Read moreSource§impl<B: Deref<Target = [u8]>> BitXorAssign<SplinterRef<B>> for Splinter
impl<B: Deref<Target = [u8]>> BitXorAssign<SplinterRef<B>> for Splinter
Source§fn bitxor_assign(&mut self, rhs: SplinterRef<B>)
fn bitxor_assign(&mut self, rhs: SplinterRef<B>)
Performs the
^= operation. Read moreSource§impl BitXorAssign for Splinter
impl BitXorAssign for Splinter
Source§fn bitxor_assign(&mut self, rhs: Splinter)
fn bitxor_assign(&mut self, rhs: Splinter)
Performs the
^= operation. Read moreSource§impl Encodable for Splinter
impl Encodable for Splinter
Source§impl Extend<u32> for Splinter
impl Extend<u32> for Splinter
Source§fn extend<T: IntoIterator<Item = u32>>(&mut self, iter: T)
fn extend<T: IntoIterator<Item = u32>>(&mut self, iter: T)
Extends a collection with the contents of an iterator. Read more
Source§fn extend_one(&mut self, item: A)
fn extend_one(&mut self, item: A)
🔬This is a nightly-only experimental API. (
extend_one)Extends a collection with exactly one element.
Source§fn extend_reserve(&mut self, additional: usize)
fn extend_reserve(&mut self, additional: usize)
🔬This is a nightly-only experimental API. (
extend_one)Reserves capacity in a collection for the given number of additional elements. Read more
Source§impl<B: Deref<Target = [u8]>> From<CowSplinter<B>> for Splinter
impl<B: Deref<Target = [u8]>> From<CowSplinter<B>> for Splinter
Source§fn from(cow_splinter: CowSplinter<B>) -> Self
fn from(cow_splinter: CowSplinter<B>) -> Self
Converts to this type from the input type.
Source§impl<B> From<Splinter> for CowSplinter<B>
impl<B> From<Splinter> for CowSplinter<B>
Source§impl FromIterator<u32> for Splinter
impl FromIterator<u32> for Splinter
Source§impl Optimizable for Splinter
impl Optimizable for Splinter
Source§impl<B> PartialEq<Splinter> for SplinterRef<B>
impl<B> PartialEq<Splinter> for SplinterRef<B>
Source§impl PartitionRead<High> for Splinter
impl PartitionRead<High> for Splinter
Source§fn cardinality(&self) -> usize
fn cardinality(&self) -> usize
Returns the total number of elements in this splinter.
§Examples
use splinter_rs::{Splinter, PartitionRead, PartitionWrite};
let mut splinter = Splinter::EMPTY;
assert_eq!(splinter.cardinality(), 0);
let splinter = Splinter::from_iter([100, 200, 300]);
assert_eq!(splinter.cardinality(), 3);Source§fn is_empty(&self) -> bool
fn is_empty(&self) -> bool
Returns true if this splinter contains no elements.
§Examples
use splinter_rs::{Splinter, PartitionRead, PartitionWrite};
let mut splinter = Splinter::EMPTY;
assert!(splinter.is_empty());
let splinter = Splinter::from_iter([42]);
assert!(!splinter.is_empty());Source§fn contains(&self, value: u32) -> bool
fn contains(&self, value: u32) -> bool
Returns true if this splinter contains the specified value.
§Examples
use splinter_rs::{Splinter, PartitionRead, PartitionWrite};
let splinter = Splinter::from_iter([42, 1337]);
assert!(splinter.contains(42));
assert!(splinter.contains(1337));
assert!(!splinter.contains(999));Source§fn position(&self, value: u32) -> Option<usize>
fn position(&self, value: u32) -> Option<usize>
Returns the 0-based position of the value in this splinter if it exists.
This method searches for the given value in the splinter and returns its position
in the sorted sequence of all elements. If the value doesn’t exist, returns None.
§Examples
use splinter_rs::{Splinter, PartitionRead, PartitionWrite};
let splinter = Splinter::from_iter([10, 20, 30]);
assert_eq!(splinter.position(10), Some(0));
assert_eq!(splinter.position(20), Some(1));
assert_eq!(splinter.position(30), Some(2));
assert_eq!(splinter.position(25), None); // doesn't existSource§fn rank(&self, value: u32) -> usize
fn rank(&self, value: u32) -> usize
Returns the number of elements in this splinter that are less than or equal to the given value.
This is also known as the “rank” of the value in the sorted sequence of all elements.
§Examples
use splinter_rs::{Splinter, PartitionRead, PartitionWrite};
let splinter = Splinter::from_iter([10, 20, 30]);
assert_eq!(splinter.rank(5), 0); // No elements <= 5
assert_eq!(splinter.rank(10), 1); // One element <= 10
assert_eq!(splinter.rank(25), 2); // Two elements <= 25
assert_eq!(splinter.rank(30), 3); // Three elements <= 30
assert_eq!(splinter.rank(50), 3); // Three elements <= 50Source§fn select(&self, idx: usize) -> Option<u32>
fn select(&self, idx: usize) -> Option<u32>
Returns the element at the given index in the sorted sequence, or None if the index is out of bounds.
The index is 0-based, so select(0) returns the smallest element.
§Examples
use splinter_rs::{Splinter, PartitionRead, PartitionWrite};
let splinter = Splinter::from_iter([100, 50, 200]);
assert_eq!(splinter.select(0), Some(50)); // Smallest element
assert_eq!(splinter.select(1), Some(100)); // Second smallest
assert_eq!(splinter.select(2), Some(200)); // Largest element
assert_eq!(splinter.select(3), None); // Out of boundsSource§fn last(&self) -> Option<u32>
fn last(&self) -> Option<u32>
Returns the largest element in this splinter, or None if it’s empty.
§Examples
use splinter_rs::{Splinter, PartitionRead, PartitionWrite};
let mut splinter = Splinter::EMPTY;
assert_eq!(splinter.last(), None);
let splinter = Splinter::from_iter([100, 50, 200]);
assert_eq!(splinter.last(), Some(200));Source§fn iter(&self) -> impl Iterator<Item = u32>
fn iter(&self) -> impl Iterator<Item = u32>
Returns an iterator over all elements in ascending order.
§Examples
use splinter_rs::{Splinter, PartitionRead, PartitionWrite};
let splinter = Splinter::from_iter([300, 100, 200]);
let values: Vec<u32> = splinter.iter().collect();
assert_eq!(values, vec![100, 200, 300]);Source§fn contains_all<R: RangeBounds<u32>>(&self, values: R) -> bool
fn contains_all<R: RangeBounds<u32>>(&self, values: R) -> bool
Returns true if this splinter contains all values in the specified range.
This method checks whether every value within the given range bounds is present
in the splinter. An empty range is trivially contained and returns true.
§Examples
use splinter_rs::{Splinter, PartitionRead};
let splinter = Splinter::from_iter([10, 11, 12, 13, 14, 15, 100]);
// Check if range is fully contained
assert!(splinter.contains_all(10..=15));
assert!(splinter.contains_all(11..=14));
// Missing values mean the range is not fully contained
assert!(!splinter.contains_all(10..=16)); // 16 is missing
assert!(!splinter.contains_all(9..=15)); // 9 is missing
// Empty ranges are trivially contained
assert!(splinter.contains_all(50..50));Source§fn contains_any<R: RangeBounds<u32>>(&self, values: R) -> bool
fn contains_any<R: RangeBounds<u32>>(&self, values: R) -> bool
Returns true if this splinter has a non-empty intersection with the specified range.
This method checks whether any value within the given range is present
in the splinter. Returns false for empty ranges.
§Examples
use splinter_rs::{Splinter, PartitionRead};
let splinter = Splinter::from_iter([10, 20, 30]);
// Check for any overlap
assert!(splinter.contains_any(10..=15)); // Contains 10
assert!(splinter.contains_any(5..=10)); // Contains 10
assert!(splinter.contains_any(25..=35)); // Contains 30
// No overlap
assert!(!splinter.contains_any(0..=9)); // No values in range
assert!(!splinter.contains_any(40..=50)); // No values in range
// Empty ranges have no intersection
assert!(!splinter.contains_any(50..50));Source§impl PartitionWrite<High> for Splinter
impl PartitionWrite<High> for Splinter
Source§fn insert(&mut self, value: u32) -> bool
fn insert(&mut self, value: u32) -> bool
Inserts a value into this splinter.
Returns true if the value was newly inserted, or false if it was already present.
§Examples
use splinter_rs::{Splinter, PartitionWrite, PartitionRead};
let mut splinter = Splinter::EMPTY;
// First insertion returns true
assert!(splinter.insert(42));
assert_eq!(splinter.cardinality(), 1);
// Second insertion of same value returns false
assert!(!splinter.insert(42));
assert_eq!(splinter.cardinality(), 1);
// Different value returns true
assert!(splinter.insert(100));
assert_eq!(splinter.cardinality(), 2);Source§fn remove(&mut self, value: u32) -> bool
fn remove(&mut self, value: u32) -> bool
Removes a value from this splinter.
Returns true if the value was present and removed, or false if it was not present.
§Examples
use splinter_rs::{Splinter, PartitionWrite, PartitionRead};
let mut splinter = Splinter::from_iter([42, 100]);
assert_eq!(splinter.cardinality(), 2);
// Remove existing value
assert!(splinter.remove(42));
assert_eq!(splinter.cardinality(), 1);
assert!(!splinter.contains(42));
assert!(splinter.contains(100));
// Remove non-existent value
assert!(!splinter.remove(999));
assert_eq!(splinter.cardinality(), 1);Source§fn remove_range<R: RangeBounds<u32>>(&mut self, values: R)
fn remove_range<R: RangeBounds<u32>>(&mut self, values: R)
Removes a range of values from this splinter.
This method removes all values that fall within the specified range bounds. The range can be inclusive, exclusive, or half-bounded using standard Rust range syntax.
§Examples
use splinter_rs::{Splinter, PartitionRead, PartitionWrite};
let mut splinter = Splinter::from_iter(1..=10);
// Remove values 3 through 7 (inclusive)
splinter.remove_range(3..=7);
assert!(!splinter.contains(5));
assert!(splinter.contains(2));
assert!(splinter.contains(8));
// Remove from 9 onwards
splinter.remove_range(9..);
assert!(!splinter.contains(9));
assert!(!splinter.contains(10));
assert!(splinter.contains(8));Source§impl<B: Deref<Target = [u8]>> SubAssign<&CowSplinter<B>> for Splinter
impl<B: Deref<Target = [u8]>> SubAssign<&CowSplinter<B>> for Splinter
Source§fn sub_assign(&mut self, rhs: &CowSplinter<B>)
fn sub_assign(&mut self, rhs: &CowSplinter<B>)
Performs the
-= operation. Read moreSource§impl SubAssign<&Splinter> for Splinter
impl SubAssign<&Splinter> for Splinter
Source§fn sub_assign(&mut self, rhs: &Splinter)
fn sub_assign(&mut self, rhs: &Splinter)
Performs the
-= operation. Read moreSource§impl<B: Deref<Target = [u8]>> SubAssign<&SplinterRef<B>> for Splinter
impl<B: Deref<Target = [u8]>> SubAssign<&SplinterRef<B>> for Splinter
Source§fn sub_assign(&mut self, rhs: &SplinterRef<B>)
fn sub_assign(&mut self, rhs: &SplinterRef<B>)
Performs the
-= operation. Read moreSource§impl<B: Deref<Target = [u8]>> SubAssign<CowSplinter<B>> for Splinter
impl<B: Deref<Target = [u8]>> SubAssign<CowSplinter<B>> for Splinter
Source§fn sub_assign(&mut self, rhs: CowSplinter<B>)
fn sub_assign(&mut self, rhs: CowSplinter<B>)
Performs the
-= operation. Read moreSource§impl<B: Deref<Target = [u8]>> SubAssign<SplinterRef<B>> for Splinter
impl<B: Deref<Target = [u8]>> SubAssign<SplinterRef<B>> for Splinter
Source§fn sub_assign(&mut self, rhs: SplinterRef<B>)
fn sub_assign(&mut self, rhs: SplinterRef<B>)
Performs the
-= operation. Read moreSource§impl SubAssign for Splinter
impl SubAssign for Splinter
Source§fn sub_assign(&mut self, rhs: Splinter)
fn sub_assign(&mut self, rhs: Splinter)
Performs the
-= operation. Read moreimpl Eq for Splinter
impl StructuralPartialEq for Splinter
Auto Trait Implementations§
impl Freeze for Splinter
impl RefUnwindSafe for Splinter
impl Send for Splinter
impl Sync for Splinter
impl Unpin for Splinter
impl UnwindSafe for Splinter
Blanket Implementations§
Source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
Source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
Source§impl<T> CloneToUninit for Twhere
T: Clone,
impl<T> CloneToUninit for Twhere
T: Clone,
Source§impl<T> FmtForward for T
impl<T> FmtForward for T
Source§fn fmt_binary(self) -> FmtBinary<Self>where
Self: Binary,
fn fmt_binary(self) -> FmtBinary<Self>where
Self: Binary,
Causes
self to use its Binary implementation when Debug-formatted.Source§fn fmt_display(self) -> FmtDisplay<Self>where
Self: Display,
fn fmt_display(self) -> FmtDisplay<Self>where
Self: Display,
Causes
self to use its Display implementation when
Debug-formatted.Source§fn fmt_lower_exp(self) -> FmtLowerExp<Self>where
Self: LowerExp,
fn fmt_lower_exp(self) -> FmtLowerExp<Self>where
Self: LowerExp,
Causes
self to use its LowerExp implementation when
Debug-formatted.Source§fn fmt_lower_hex(self) -> FmtLowerHex<Self>where
Self: LowerHex,
fn fmt_lower_hex(self) -> FmtLowerHex<Self>where
Self: LowerHex,
Causes
self to use its LowerHex implementation when
Debug-formatted.Source§fn fmt_octal(self) -> FmtOctal<Self>where
Self: Octal,
fn fmt_octal(self) -> FmtOctal<Self>where
Self: Octal,
Causes
self to use its Octal implementation when Debug-formatted.Source§fn fmt_pointer(self) -> FmtPointer<Self>where
Self: Pointer,
fn fmt_pointer(self) -> FmtPointer<Self>where
Self: Pointer,
Causes
self to use its Pointer implementation when
Debug-formatted.Source§fn fmt_upper_exp(self) -> FmtUpperExp<Self>where
Self: UpperExp,
fn fmt_upper_exp(self) -> FmtUpperExp<Self>where
Self: UpperExp,
Causes
self to use its UpperExp implementation when
Debug-formatted.Source§fn fmt_upper_hex(self) -> FmtUpperHex<Self>where
Self: UpperHex,
fn fmt_upper_hex(self) -> FmtUpperHex<Self>where
Self: UpperHex,
Causes
self to use its UpperHex implementation when
Debug-formatted.Source§impl<T> IntoEither for T
impl<T> IntoEither for T
Source§fn into_either(self, into_left: bool) -> Either<Self, Self>
fn into_either(self, into_left: bool) -> Either<Self, Self>
Converts
self into a Left variant of Either<Self, Self>
if into_left is true.
Converts self into a Right variant of Either<Self, Self>
otherwise. Read moreSource§fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
Converts
self into a Left variant of Either<Self, Self>
if into_left(&self) returns true.
Converts self into a Right variant of Either<Self, Self>
otherwise. Read moreSource§impl<T> Pipe for Twhere
T: ?Sized,
impl<T> Pipe for Twhere
T: ?Sized,
Source§fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> Rwhere
Self: Sized,
fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> Rwhere
Self: Sized,
Pipes by value. This is generally the method you want to use. Read more
Source§fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> Rwhere
R: 'a,
fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> Rwhere
R: 'a,
Borrows
self and passes that borrow into the pipe function. Read moreSource§fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> Rwhere
R: 'a,
fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> Rwhere
R: 'a,
Mutably borrows
self and passes that borrow into the pipe function. Read moreSource§fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R
fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R
Source§fn pipe_borrow_mut<'a, B, R>(
&'a mut self,
func: impl FnOnce(&'a mut B) -> R,
) -> R
fn pipe_borrow_mut<'a, B, R>( &'a mut self, func: impl FnOnce(&'a mut B) -> R, ) -> R
Source§fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R
fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R
Borrows
self, then passes self.as_ref() into the pipe function.Source§fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R
fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R
Mutably borrows
self, then passes self.as_mut() into the pipe
function.Source§fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R
fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R
Borrows
self, then passes self.deref() into the pipe function.Source§impl<T> Tap for T
impl<T> Tap for T
Source§fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self
fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self
Immutable access to the
Borrow<B> of a value. Read moreSource§fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self
fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self
Mutable access to the
BorrowMut<B> of a value. Read moreSource§fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self
fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self
Immutable access to the
AsRef<R> view of a value. Read moreSource§fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self
fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self
Mutable access to the
AsMut<R> view of a value. Read moreSource§fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self
fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self
Immutable access to the
Deref::Target of a value. Read moreSource§fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self
fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self
Mutable access to the
Deref::Target of a value. Read moreSource§fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self
fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self
Calls
.tap() only in debug builds, and is erased in release builds.Source§fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self
fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self
Calls
.tap_mut() only in debug builds, and is erased in release
builds.Source§fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self
fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self
Calls
.tap_borrow() only in debug builds, and is erased in release
builds.Source§fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Self
fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Self
Calls
.tap_borrow_mut() only in debug builds, and is erased in release
builds.Source§fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self
fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self
Calls
.tap_ref() only in debug builds, and is erased in release
builds.Source§fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Self
fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Self
Calls
.tap_ref_mut() only in debug builds, and is erased in release
builds.Source§fn tap_deref_dbg<T>(self, func: impl FnOnce(&T)) -> Self
fn tap_deref_dbg<T>(self, func: impl FnOnce(&T)) -> Self
Calls
.tap_deref() only in debug builds, and is erased in release
builds.