pub(crate) fn sp_bitop_assign(
		&mut self,
		rhs: &Self,
		word_op: fn(usize, usize) -> usize,
		bool_op: fn(bool, bool) -> bool,
	) {
		let (mut this, mut that) = (self, rhs);
		while this.len() >= WORD_BITS && that.len() >= WORD_BITS {
			unsafe {
				let (l, left) = this.split_at_unchecked_mut_noalias(WORD_BITS);
				let (r, right) = that.split_at_unchecked(WORD_BITS);
				this = left;
				that = right;
				let (a, b) = (l.load_le::<usize>(), r.load_le::<usize>());
				l.store_le(word_op(a, b));
			}
		}
		//  Note: it might actually be possible to do a partial-word load/store
		//  to exhaust the shorter bit-slice. Investigate further.
		for (l, r) in this
			.as_mut_bitptr_range()
			.zip(that.iter().by_vals().chain(iter::repeat(false)))
		{
			unsafe {
				l.write(bool_op(l.read(), r));
			}
		}
	}
/// Accelerates Boolean arithmetic.
///
/// This applies a Boolean-arithmetic function across all the bits in a
/// pair. The secondary bit-slice is zero-extended if it expires before
/// `self` does.
///
/// Because the two bit-slices share the same types, this is able to
/// batch-load `usize` chunks from each, apply the arithmetic to them, and
/// write the result back into `self`. Any leftover bits are handled
/// individually.
Accelerates Boolean arithmetic.
This applies a Boolean-arithmetic function across all the bits in a
pair. The secondary bit-slice is zero-extended if it expires before
`self` does.

Because the two bit-slices share the same types, this is able to
batch-load `usize` chunks from each, apply the arithmetic to them, and
write the result back into `self`. Any leftover bits are handled
individually.
Accelerates Boolean arithmetic . This applies a Boolean - arithmetic function across all the bits in a pair . The secondary bit - slice is zero - extended if it expires before ` self ` does . Because the two bit - slices share the same types this is able to batch - load ` usize ` chunks from each apply the arithmetic to them and write the result back into ` self ` . Any leftover bits are handled individually .
pub(crate) fn sp_bitop_assign(
		&mut self,
		rhs: &Self,
		word_op: fn(usize, usize) -> usize,
		bool_op: fn(bool, bool) -> bool,
	) {
		let (mut this, mut that) = (self, rhs);
		while this.len() >= WORD_BITS && that.len() >= WORD_BITS {
			unsafe {
				let (l, left) = this.split_at_unchecked_mut_noalias(WORD_BITS);
				let (r, right) = that.split_at_unchecked(WORD_BITS);
				this = left;
				that = right;
				let (a, b) = (l.load_le::<usize>(), r.load_le::<usize>());
				l.store_le(word_op(a, b));
			}
		}
		//  Note: it might actually be possible to do a partial-word load/store
		//  to exhaust the shorter bit-slice. Investigate further.
		for (l, r) in this
			.as_mut_bitptr_range()
			.zip(that.iter().by_vals().chain(iter::repeat(false)))
		{
			unsafe {
				l.write(bool_op(l.read(), r));
			}
		}
	}
pub ( crate ) fn sp_bitop_assign ( & mut self , rhs : & Self , word_op : fn ( usize , usize ) -> usize , bool_op : fn ( bool , bool ) -> bool , ) { let ( mut this , mut that ) = ( self , rhs ) ; while this . len ( ) >= WORD_BITS && that . len ( ) >= WORD_BITS { unsafe { let ( l , left ) = this . split_at_unchecked_mut_noalias ( WORD_BITS ) ; let ( r , right ) = that . split_at_unchecked ( WORD_BITS ) ; this = left ; that = right ; let ( a , b ) = ( l . load_le :: < usize > ( ) , r . load_le :: < usize > ( ) ) ; l . store_le ( word_op ( a , b ) ) ; } } //  Note: it might actually be possible to do a partial-word load/store //  to exhaust the shorter bit-slice. Investigate further. for ( l , r ) in this . as_mut_bitptr_range ( ) . zip ( that . iter ( ) . by_vals ( ) . chain ( iter :: repeat ( false ) ) ) { unsafe { l . write ( bool_op ( l . read ( ) , r ) ) ; } } }
Accelerates Boolean arithmetic.
Accelerates Boolean arithmetic .
&mut self
rhs
&Self
word_op
fn(usize, usize) -> usize
bool_op
fn(bool, bool) -> bool
&mut self
rhs
&Self
word_op
fn(usize, usize) -> usize
bool_op
fn(bool, bool) -> bool