Trait bv::BitSliceable

pub trait BitSliceable<Range> {
    type Slice;
    fn bit_slice(self, range: Range) -> Self::Slice;
}

Types that support slicing by ranges.

Associated Types

type Slice

The type of the slice produced.

Required Methods

fn bit_slice(self, range: Range) -> Self::Slice

Slices or re-slices the given object.

Examples

use bv::{BitSlice, BitSliceable};

let array = [0b01010011u16];
let slice = BitSlice::from_slice(&array);

assert_eq!( slice.bit_slice(1..3), slice.bit_slice(4..6) );
assert_eq!( slice.bit_slice(1..3), slice.bit_slice(6..8) );

assert_ne!( slice.bit_slice(2..4), slice.bit_slice(6..8) );
assert_eq!( slice.bit_slice(2..4), slice.bit_slice(7..9) );

Implementations on Foreign Types

impl<'a, Block: BlockType> BitSliceable<Range<u64>> for &'a [Block]

type Slice = BitSlice<'a, Block>

fn bit_slice(self, range: Range<u64>) -> Self::Slice

impl<'a, Block: BlockType> BitSliceable<Range<u64>> for &'a mut [Block]

type Slice = BitSliceMut<'a, Block>

fn bit_slice(self, range: Range<u64>) -> Self::Slice

impl<'a, Block: BlockType> BitSliceable<RangeInclusive<u64>> for &'a [Block]

type Slice = BitSlice<'a, Block>

fn bit_slice(self, range: RangeInclusive<u64>) -> Self::Slice

impl<'a, Block: BlockType> BitSliceable<RangeInclusive<u64>> for &'a mut [Block]

type Slice = BitSliceMut<'a, Block>

fn bit_slice(self, range: RangeInclusive<u64>) -> Self::Slice

impl<'a, Block: BlockType> BitSliceable<RangeFrom<u64>> for &'a [Block]

type Slice = BitSlice<'a, Block>

fn bit_slice(self, range: RangeFrom<u64>) -> Self::Slice

impl<'a, Block: BlockType> BitSliceable<RangeFrom<u64>> for &'a mut [Block]

type Slice = BitSliceMut<'a, Block>

fn bit_slice(self, range: RangeFrom<u64>) -> Self::Slice

impl<'a, Block: BlockType> BitSliceable<RangeTo<u64>> for &'a [Block]

type Slice = BitSlice<'a, Block>

fn bit_slice(self, range: RangeTo<u64>) -> Self::Slice

impl<'a, Block: BlockType> BitSliceable<RangeTo<u64>> for &'a mut [Block]

type Slice = BitSliceMut<'a, Block>

fn bit_slice(self, range: RangeTo<u64>) -> Self::Slice

impl<'a, Block: BlockType> BitSliceable<RangeToInclusive<u64>> for &'a [Block]

type Slice = BitSlice<'a, Block>

fn bit_slice(self, range: RangeToInclusive<u64>) -> Self::Slice

impl<'a, Block: BlockType> BitSliceable<RangeToInclusive<u64>> for &'a mut [Block]

type Slice = BitSliceMut<'a, Block>

fn bit_slice(self, range: RangeToInclusive<u64>) -> Self::Slice

impl<'a, Block: BlockType> BitSliceable<RangeFull> for &'a [Block]

type Slice = BitSlice<'a, Block>

fn bit_slice(self, _: RangeFull) -> Self::Slice

impl<'a, Block: BlockType> BitSliceable<RangeFull> for &'a mut [Block]

type Slice = BitSliceMut<'a, Block>

fn bit_slice(self, _: RangeFull) -> Self::Slice

impl<'a> BitSliceable<Range<usize>> for &'a [bool]

type Slice = &'a [bool]

fn bit_slice(self, range: Range<usize>) -> &'a [bool]

impl<'a> BitSliceable<Range<usize>> for &'a mut [bool]

type Slice = &'a mut [bool]

fn bit_slice(self, range: Range<usize>) -> &'a mut [bool]

impl<'a> BitSliceable<RangeInclusive<usize>> for &'a [bool]

type Slice = &'a [bool]

fn bit_slice(self, range: RangeInclusive<usize>) -> &'a [bool]

impl<'a> BitSliceable<RangeInclusive<usize>> for &'a mut [bool]

type Slice = &'a mut [bool]

fn bit_slice(self, range: RangeInclusive<usize>) -> &'a mut [bool]

impl<'a> BitSliceable<RangeFrom<usize>> for &'a [bool]

type Slice = &'a [bool]

fn bit_slice(self, range: RangeFrom<usize>) -> &'a [bool]

impl<'a> BitSliceable<RangeFrom<usize>> for &'a mut [bool]

type Slice = &'a mut [bool]

fn bit_slice(self, range: RangeFrom<usize>) -> &'a mut [bool]

impl<'a> BitSliceable<RangeTo<usize>> for &'a [bool]

type Slice = &'a [bool]

fn bit_slice(self, range: RangeTo<usize>) -> &'a [bool]

impl<'a> BitSliceable<RangeTo<usize>> for &'a mut [bool]

type Slice = &'a mut [bool]

fn bit_slice(self, range: RangeTo<usize>) -> &'a mut [bool]

impl<'a> BitSliceable<RangeToInclusive<usize>> for &'a [bool]

type Slice = &'a [bool]

fn bit_slice(self, range: RangeToInclusive<usize>) -> &'a [bool]

impl<'a> BitSliceable<RangeToInclusive<usize>> for &'a mut [bool]

type Slice = &'a mut [bool]

fn bit_slice(self, range: RangeToInclusive<usize>) -> &'a mut [bool]

impl<'a> BitSliceable<RangeFull> for &'a [bool]

type Slice = &'a [bool]

fn bit_slice(self, _: RangeFull) -> &'a [bool]

impl<'a> BitSliceable<RangeFull> for &'a mut [bool]

type Slice = &'a mut [bool]

fn bit_slice(self, _: RangeFull) -> &'a mut [bool]

impl<'a, R, Block: BlockType> BitSliceable<R> for &'a [Block; 0] where     &'a [Block]: BitSliceable<R>,

type Slice = <&'a [Block] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R> BitSliceable<R> for &'a [bool; 0] where     &'a [bool]: BitSliceable<R>,

type Slice = <&'a [bool] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R, Block: BlockType> BitSliceable<R> for &'a [Block; 1] where     &'a [Block]: BitSliceable<R>,

type Slice = <&'a [Block] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R> BitSliceable<R> for &'a [bool; 1] where     &'a [bool]: BitSliceable<R>,

type Slice = <&'a [bool] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R, Block: BlockType> BitSliceable<R> for &'a [Block; 2] where     &'a [Block]: BitSliceable<R>,

type Slice = <&'a [Block] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R> BitSliceable<R> for &'a [bool; 2] where     &'a [bool]: BitSliceable<R>,

type Slice = <&'a [bool] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R, Block: BlockType> BitSliceable<R> for &'a [Block; 3] where     &'a [Block]: BitSliceable<R>,

type Slice = <&'a [Block] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R> BitSliceable<R> for &'a [bool; 3] where     &'a [bool]: BitSliceable<R>,

type Slice = <&'a [bool] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R, Block: BlockType> BitSliceable<R> for &'a [Block; 4] where     &'a [Block]: BitSliceable<R>,

type Slice = <&'a [Block] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R> BitSliceable<R> for &'a [bool; 4] where     &'a [bool]: BitSliceable<R>,

type Slice = <&'a [bool] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R, Block: BlockType> BitSliceable<R> for &'a [Block; 5] where     &'a [Block]: BitSliceable<R>,

type Slice = <&'a [Block] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R> BitSliceable<R> for &'a [bool; 5] where     &'a [bool]: BitSliceable<R>,

type Slice = <&'a [bool] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R, Block: BlockType> BitSliceable<R> for &'a [Block; 6] where     &'a [Block]: BitSliceable<R>,

type Slice = <&'a [Block] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R> BitSliceable<R> for &'a [bool; 6] where     &'a [bool]: BitSliceable<R>,

type Slice = <&'a [bool] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R, Block: BlockType> BitSliceable<R> for &'a [Block; 7] where     &'a [Block]: BitSliceable<R>,

type Slice = <&'a [Block] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R> BitSliceable<R> for &'a [bool; 7] where     &'a [bool]: BitSliceable<R>,

type Slice = <&'a [bool] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R, Block: BlockType> BitSliceable<R> for &'a [Block; 8] where     &'a [Block]: BitSliceable<R>,

type Slice = <&'a [Block] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R> BitSliceable<R> for &'a [bool; 8] where     &'a [bool]: BitSliceable<R>,

type Slice = <&'a [bool] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R, Block: BlockType> BitSliceable<R> for &'a [Block; 9] where     &'a [Block]: BitSliceable<R>,

type Slice = <&'a [Block] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R> BitSliceable<R> for &'a [bool; 9] where     &'a [bool]: BitSliceable<R>,

type Slice = <&'a [bool] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R, Block: BlockType> BitSliceable<R> for &'a [Block; 10] where     &'a [Block]: BitSliceable<R>,

type Slice = <&'a [Block] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R> BitSliceable<R> for &'a [bool; 10] where     &'a [bool]: BitSliceable<R>,

type Slice = <&'a [bool] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R, Block: BlockType> BitSliceable<R> for &'a [Block; 11] where     &'a [Block]: BitSliceable<R>,

type Slice = <&'a [Block] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R> BitSliceable<R> for &'a [bool; 11] where     &'a [bool]: BitSliceable<R>,

type Slice = <&'a [bool] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R, Block: BlockType> BitSliceable<R> for &'a [Block; 12] where     &'a [Block]: BitSliceable<R>,

type Slice = <&'a [Block] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R> BitSliceable<R> for &'a [bool; 12] where     &'a [bool]: BitSliceable<R>,

type Slice = <&'a [bool] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R, Block: BlockType> BitSliceable<R> for &'a [Block; 13] where     &'a [Block]: BitSliceable<R>,

type Slice = <&'a [Block] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R> BitSliceable<R> for &'a [bool; 13] where     &'a [bool]: BitSliceable<R>,

type Slice = <&'a [bool] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R, Block: BlockType> BitSliceable<R> for &'a [Block; 14] where     &'a [Block]: BitSliceable<R>,

type Slice = <&'a [Block] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R> BitSliceable<R> for &'a [bool; 14] where     &'a [bool]: BitSliceable<R>,

type Slice = <&'a [bool] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R, Block: BlockType> BitSliceable<R> for &'a [Block; 15] where     &'a [Block]: BitSliceable<R>,

type Slice = <&'a [Block] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R> BitSliceable<R> for &'a [bool; 15] where     &'a [bool]: BitSliceable<R>,

type Slice = <&'a [bool] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R, Block: BlockType> BitSliceable<R> for &'a [Block; 16] where     &'a [Block]: BitSliceable<R>,

type Slice = <&'a [Block] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R> BitSliceable<R> for &'a [bool; 16] where     &'a [bool]: BitSliceable<R>,

type Slice = <&'a [bool] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R, Block: BlockType> BitSliceable<R> for &'a [Block; 17] where     &'a [Block]: BitSliceable<R>,

type Slice = <&'a [Block] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R> BitSliceable<R> for &'a [bool; 17] where     &'a [bool]: BitSliceable<R>,

type Slice = <&'a [bool] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R, Block: BlockType> BitSliceable<R> for &'a [Block; 18] where     &'a [Block]: BitSliceable<R>,

type Slice = <&'a [Block] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R> BitSliceable<R> for &'a [bool; 18] where     &'a [bool]: BitSliceable<R>,

type Slice = <&'a [bool] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R, Block: BlockType> BitSliceable<R> for &'a [Block; 19] where     &'a [Block]: BitSliceable<R>,

type Slice = <&'a [Block] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R> BitSliceable<R> for &'a [bool; 19] where     &'a [bool]: BitSliceable<R>,

type Slice = <&'a [bool] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R, Block: BlockType> BitSliceable<R> for &'a [Block; 20] where     &'a [Block]: BitSliceable<R>,

type Slice = <&'a [Block] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R> BitSliceable<R> for &'a [bool; 20] where     &'a [bool]: BitSliceable<R>,

type Slice = <&'a [bool] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R, Block: BlockType> BitSliceable<R> for &'a [Block; 21] where     &'a [Block]: BitSliceable<R>,

type Slice = <&'a [Block] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R> BitSliceable<R> for &'a [bool; 21] where     &'a [bool]: BitSliceable<R>,

type Slice = <&'a [bool] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R, Block: BlockType> BitSliceable<R> for &'a [Block; 22] where     &'a [Block]: BitSliceable<R>,

type Slice = <&'a [Block] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R> BitSliceable<R> for &'a [bool; 22] where     &'a [bool]: BitSliceable<R>,

type Slice = <&'a [bool] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R, Block: BlockType> BitSliceable<R> for &'a [Block; 23] where     &'a [Block]: BitSliceable<R>,

type Slice = <&'a [Block] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R> BitSliceable<R> for &'a [bool; 23] where     &'a [bool]: BitSliceable<R>,

type Slice = <&'a [bool] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R, Block: BlockType> BitSliceable<R> for &'a [Block; 24] where     &'a [Block]: BitSliceable<R>,

type Slice = <&'a [Block] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R> BitSliceable<R> for &'a [bool; 24] where     &'a [bool]: BitSliceable<R>,

type Slice = <&'a [bool] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R, Block: BlockType> BitSliceable<R> for &'a [Block; 25] where     &'a [Block]: BitSliceable<R>,

type Slice = <&'a [Block] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R> BitSliceable<R> for &'a [bool; 25] where     &'a [bool]: BitSliceable<R>,

type Slice = <&'a [bool] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R, Block: BlockType> BitSliceable<R> for &'a [Block; 26] where     &'a [Block]: BitSliceable<R>,

type Slice = <&'a [Block] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R> BitSliceable<R> for &'a [bool; 26] where     &'a [bool]: BitSliceable<R>,

type Slice = <&'a [bool] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R, Block: BlockType> BitSliceable<R> for &'a [Block; 27] where     &'a [Block]: BitSliceable<R>,

type Slice = <&'a [Block] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R> BitSliceable<R> for &'a [bool; 27] where     &'a [bool]: BitSliceable<R>,

type Slice = <&'a [bool] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R, Block: BlockType> BitSliceable<R> for &'a [Block; 28] where     &'a [Block]: BitSliceable<R>,

type Slice = <&'a [Block] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R> BitSliceable<R> for &'a [bool; 28] where     &'a [bool]: BitSliceable<R>,

type Slice = <&'a [bool] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R, Block: BlockType> BitSliceable<R> for &'a [Block; 29] where     &'a [Block]: BitSliceable<R>,

type Slice = <&'a [Block] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R> BitSliceable<R> for &'a [bool; 29] where     &'a [bool]: BitSliceable<R>,

type Slice = <&'a [bool] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R, Block: BlockType> BitSliceable<R> for &'a [Block; 30] where     &'a [Block]: BitSliceable<R>,

type Slice = <&'a [Block] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R> BitSliceable<R> for &'a [bool; 30] where     &'a [bool]: BitSliceable<R>,

type Slice = <&'a [bool] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R, Block: BlockType> BitSliceable<R> for &'a [Block; 31] where     &'a [Block]: BitSliceable<R>,

type Slice = <&'a [Block] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

impl<'a, R> BitSliceable<R> for &'a [bool; 31] where     &'a [bool]: BitSliceable<R>,

type Slice = <&'a [bool] as BitSliceable<R>>::Slice

fn bit_slice(self, range: R) -> Self::Slice

Implementors

• impl<'a, Block: BlockType> BitSliceable<Range<u64>> for BitSlice<'a, Block> type Slice = Self;

• impl<'a, Block: BlockType> BitSliceable<Range<u64>> for BitSliceMut<'a, Block> type Slice = Self;

• impl<'a, Block: BlockType> BitSliceable<RangeInclusive<u64>> for BitSlice<'a, Block> type Slice = Self;

• impl<'a, Block: BlockType> BitSliceable<RangeInclusive<u64>> for BitSliceMut<'a, Block> type Slice = Self;

• impl<'a, Block: BlockType> BitSliceable<RangeFrom<u64>> for BitSlice<'a, Block> type Slice = Self;

• impl<'a, Block: BlockType> BitSliceable<RangeFrom<u64>> for BitSliceMut<'a, Block> type Slice = Self;

• impl<'a, Block: BlockType> BitSliceable<RangeTo<u64>> for BitSlice<'a, Block> type Slice = Self;

• impl<'a, Block: BlockType> BitSliceable<RangeTo<u64>> for BitSliceMut<'a, Block> type Slice = Self;

• impl<'a, Block: BlockType> BitSliceable<RangeToInclusive<u64>> for BitSlice<'a, Block> type Slice = Self;

• impl<'a, Block: BlockType> BitSliceable<RangeToInclusive<u64>> for BitSliceMut<'a, Block> type Slice = Self;

• impl<'a, Block: BlockType> BitSliceable<RangeFull> for BitSlice<'a, Block> type Slice = Self;

• impl<'a, Block: BlockType> BitSliceable<RangeFull> for BitSliceMut<'a, Block> type Slice = Self;

• impl<'a, Block: BlockType> BitSliceable<Range<u64>> for &'a BitVec<Block> type Slice = BitSlice<'a, Block>;

• impl<'a, Block: BlockType> BitSliceable<Range<u64>> for &'a mut BitVec<Block> type Slice = BitSliceMut<'a, Block>;

• impl<'a, Block: BlockType> BitSliceable<RangeInclusive<u64>> for &'a BitVec<Block> type Slice = BitSlice<'a, Block>;

• impl<'a, Block: BlockType> BitSliceable<RangeInclusive<u64>> for &'a mut BitVec<Block> type Slice = BitSliceMut<'a, Block>;

• impl<'a, Block: BlockType> BitSliceable<RangeFrom<u64>> for &'a BitVec<Block> type Slice = BitSlice<'a, Block>;

• impl<'a, Block: BlockType> BitSliceable<RangeFrom<u64>> for &'a mut BitVec<Block> type Slice = BitSliceMut<'a, Block>;

• impl<'a, Block: BlockType> BitSliceable<RangeTo<u64>> for &'a BitVec<Block> type Slice = BitSlice<'a, Block>;

• impl<'a, Block: BlockType> BitSliceable<RangeTo<u64>> for &'a mut BitVec<Block> type Slice = BitSliceMut<'a, Block>;

• impl<'a, Block: BlockType> BitSliceable<RangeToInclusive<u64>> for &'a BitVec<Block> type Slice = BitSlice<'a, Block>;

• impl<'a, Block: BlockType> BitSliceable<RangeToInclusive<u64>> for &'a mut BitVec<Block> type Slice = BitSliceMut<'a, Block>;

• impl<'a, Block: BlockType> BitSliceable<RangeFull> for &'a BitVec<Block> type Slice = BitSlice<'a, Block>;

• impl<'a, Block: BlockType> BitSliceable<RangeFull> for &'a mut BitVec<Block> type Slice = BitSliceMut<'a, Block>;

• impl<T: Bits> BitSliceable<Range<u64>> for BitSliceAdapter<T> type Slice = Self;

• impl<T: Bits> BitSliceable<RangeTo<u64>> for BitSliceAdapter<T> type Slice = Self;

• impl<T: Bits> BitSliceable<RangeFrom<u64>> for BitSliceAdapter<T> type Slice = Self;

• impl<T: Bits> BitSliceable<RangeFull> for BitSliceAdapter<T> type Slice = Self;

• impl<T: Bits> BitSliceable<RangeInclusive<u64>> for BitSliceAdapter<T> type Slice = Self;

• impl<T: Bits> BitSliceable<RangeToInclusive<u64>> for BitSliceAdapter<T> type Slice = Self;

• impl<'a, T: Bits> BitSliceable<Range<u64>> for &'a BitSliceAdapter<T> type Slice = BitSliceAdapter<&'a T>;

• impl<'a, T: Bits> BitSliceable<RangeTo<u64>> for &'a BitSliceAdapter<T> type Slice = BitSliceAdapter<&'a T>;

• impl<'a, T: Bits> BitSliceable<RangeFrom<u64>> for &'a BitSliceAdapter<T> type Slice = BitSliceAdapter<&'a T>;

• impl<'a, T: Bits> BitSliceable<RangeFull> for &'a BitSliceAdapter<T> type Slice = BitSliceAdapter<&'a T>;

• impl<'a, T: Bits> BitSliceable<RangeInclusive<u64>> for &'a BitSliceAdapter<T> type Slice = BitSliceAdapter<&'a T>;

• impl<'a, T: Bits> BitSliceable<RangeToInclusive<u64>> for &'a BitSliceAdapter<T> type Slice = BitSliceAdapter<&'a T>;

• impl<R, T> BitSliceable<R> for BitNot<T> where     T: BitSliceable<R>,  type Slice = BitNot<T::Slice>;

• impl<'a, T: Bits> BitSliceable<Range<u64>> for &'a BitNot<T> type Slice = BitSliceAdapter<Self>;

• impl<'a, T: Bits> BitSliceable<RangeFrom<u64>> for &'a BitNot<T> type Slice = BitSliceAdapter<Self>;

• impl<'a, T: Bits> BitSliceable<RangeTo<u64>> for &'a BitNot<T> type Slice = BitSliceAdapter<Self>;

• impl<'a, T: Bits> BitSliceable<RangeFull> for &'a BitNot<T> type Slice = BitSliceAdapter<Self>;

• impl<'a, T: Bits> BitSliceable<RangeInclusive<u64>> for &'a BitNot<T> type Slice = BitSliceAdapter<Self>;

• impl<'a, T: Bits> BitSliceable<RangeToInclusive<u64>> for &'a BitNot<T> type Slice = BitSliceAdapter<Self>;

• impl<R, T, U> BitSliceable<R> for BitAnd<T, U> where     R: Clone,     T: BitSliceable<R>,     U: BitSliceable<R>,     T::Slice: Bits,     U::Slice: Bits<Block = <T::Slice as Bits>::Block>,  type Slice = BitAnd<T::Slice, U::Slice>;

• impl<'a, T: Bits, U: Bits<Block = T::Block>> BitSliceable<Range<u64>> for &'a BitAnd<T, U> type Slice = BitSliceAdapter<Self>;

• impl<'a, T: Bits, U: Bits<Block = T::Block>> BitSliceable<RangeFrom<u64>> for &'a BitAnd<T, U> type Slice = BitSliceAdapter<Self>;

• impl<'a, T: Bits, U: Bits<Block = T::Block>> BitSliceable<RangeTo<u64>> for &'a BitAnd<T, U> type Slice = BitSliceAdapter<Self>;

• impl<'a, T: Bits, U: Bits<Block = T::Block>> BitSliceable<RangeFull> for &'a BitAnd<T, U> type Slice = BitSliceAdapter<Self>;

• impl<'a, T: Bits, U: Bits<Block = T::Block>> BitSliceable<RangeInclusive<u64>> for &'a BitAnd<T, U> type Slice = BitSliceAdapter<Self>;

• impl<'a, T: Bits, U: Bits<Block = T::Block>> BitSliceable<RangeToInclusive<u64>> for &'a BitAnd<T, U> type Slice = BitSliceAdapter<Self>;

• impl<R, T, U> BitSliceable<R> for BitOr<T, U> where     R: Clone,     T: BitSliceable<R>,     U: BitSliceable<R>,     T::Slice: Bits,     U::Slice: Bits<Block = <T::Slice as Bits>::Block>,  type Slice = BitOr<T::Slice, U::Slice>;

• impl<'a, T: Bits, U: Bits<Block = T::Block>> BitSliceable<Range<u64>> for &'a BitOr<T, U> type Slice = BitSliceAdapter<Self>;

• impl<'a, T: Bits, U: Bits<Block = T::Block>> BitSliceable<RangeFrom<u64>> for &'a BitOr<T, U> type Slice = BitSliceAdapter<Self>;

• impl<'a, T: Bits, U: Bits<Block = T::Block>> BitSliceable<RangeTo<u64>> for &'a BitOr<T, U> type Slice = BitSliceAdapter<Self>;

• impl<'a, T: Bits, U: Bits<Block = T::Block>> BitSliceable<RangeFull> for &'a BitOr<T, U> type Slice = BitSliceAdapter<Self>;

• impl<'a, T: Bits, U: Bits<Block = T::Block>> BitSliceable<RangeInclusive<u64>> for &'a BitOr<T, U> type Slice = BitSliceAdapter<Self>;

• impl<'a, T: Bits, U: Bits<Block = T::Block>> BitSliceable<RangeToInclusive<u64>> for &'a BitOr<T, U> type Slice = BitSliceAdapter<Self>;

• impl<R, T, U> BitSliceable<R> for BitXor<T, U> where     R: Clone,     T: BitSliceable<R>,     U: BitSliceable<R>,     T::Slice: Bits,     U::Slice: Bits<Block = <T::Slice as Bits>::Block>,  type Slice = BitXor<T::Slice, U::Slice>;

• impl<'a, T: Bits, U: Bits<Block = T::Block>> BitSliceable<Range<u64>> for &'a BitXor<T, U> type Slice = BitSliceAdapter<Self>;

• impl<'a, T: Bits, U: Bits<Block = T::Block>> BitSliceable<RangeFrom<u64>> for &'a BitXor<T, U> type Slice = BitSliceAdapter<Self>;

• impl<'a, T: Bits, U: Bits<Block = T::Block>> BitSliceable<RangeTo<u64>> for &'a BitXor<T, U> type Slice = BitSliceAdapter<Self>;

• impl<'a, T: Bits, U: Bits<Block = T::Block>> BitSliceable<RangeFull> for &'a BitXor<T, U> type Slice = BitSliceAdapter<Self>;

• impl<'a, T: Bits, U: Bits<Block = T::Block>> BitSliceable<RangeInclusive<u64>> for &'a BitXor<T, U> type Slice = BitSliceAdapter<Self>;

• impl<'a, T: Bits, U: Bits<Block = T::Block>> BitSliceable<RangeToInclusive<u64>> for &'a BitXor<T, U> type Slice = BitSliceAdapter<Self>;

• impl<R, T, U, F> BitSliceable<R> for BitZip<T, U, F> where     R: Clone,     T: BitSliceable<R>,     U: BitSliceable<R>,     T::Slice: Bits,     U::Slice: Bits<Block = <T::Slice as Bits>::Block>,  type Slice = BitZip<T::Slice, U::Slice, F>;

• impl<'a, T: Bits, U: Bits<Block = T::Block>, F: Fn(T::Block, T::Block, usize) -> T::Block> BitSliceable<Range<u64>> for &'a BitZip<T, U, F> type Slice = BitSliceAdapter<Self>;

• impl<'a, T: Bits, U: Bits<Block = T::Block>, F: Fn(T::Block, T::Block, usize) -> T::Block> BitSliceable<RangeFrom<u64>> for &'a BitZip<T, U, F> type Slice = BitSliceAdapter<Self>;

• impl<'a, T: Bits, U: Bits<Block = T::Block>, F: Fn(T::Block, T::Block, usize) -> T::Block> BitSliceable<RangeTo<u64>> for &'a BitZip<T, U, F> type Slice = BitSliceAdapter<Self>;

• impl<'a, T: Bits, U: Bits<Block = T::Block>, F: Fn(T::Block, T::Block, usize) -> T::Block> BitSliceable<RangeFull> for &'a BitZip<T, U, F> type Slice = BitSliceAdapter<Self>;

• impl<'a, T: Bits, U: Bits<Block = T::Block>, F: Fn(T::Block, T::Block, usize) -> T::Block> BitSliceable<RangeInclusive<u64>> for &'a BitZip<T, U, F> type Slice = BitSliceAdapter<Self>;

• impl<'a, T: Bits, U: Bits<Block = T::Block>, F: Fn(T::Block, T::Block, usize) -> T::Block> BitSliceable<RangeToInclusive<u64>> for &'a BitZip<T, U, F> type Slice = BitSliceAdapter<Self>;

• impl<Block: BlockType> BitSliceable<Range<u64>> for BitFill<Block> type Slice = BitSliceAdapter<Self>;

• impl<Block: BlockType> BitSliceable<RangeFrom<u64>> for BitFill<Block> type Slice = BitSliceAdapter<Self>;

• impl<Block: BlockType> BitSliceable<RangeTo<u64>> for BitFill<Block> type Slice = BitSliceAdapter<Self>;

• impl<Block: BlockType> BitSliceable<RangeFull> for BitFill<Block> type Slice = BitSliceAdapter<Self>;

• impl<Block: BlockType> BitSliceable<RangeInclusive<u64>> for BitFill<Block> type Slice = BitSliceAdapter<Self>;

• impl<Block: BlockType> BitSliceable<RangeToInclusive<u64>> for BitFill<Block> type Slice = BitSliceAdapter<Self>;

• impl<'a, Block: BlockType> BitSliceable<Range<u64>> for &'a BitFill<Block> type Slice = BitSliceAdapter<Self>;

• impl<'a, Block: BlockType> BitSliceable<RangeFrom<u64>> for &'a BitFill<Block> type Slice = BitSliceAdapter<Self>;

• impl<'a, Block: BlockType> BitSliceable<RangeTo<u64>> for &'a BitFill<Block> type Slice = BitSliceAdapter<Self>;

• impl<'a, Block: BlockType> BitSliceable<RangeFull> for &'a BitFill<Block> type Slice = BitSliceAdapter<Self>;

• impl<'a, Block: BlockType> BitSliceable<RangeInclusive<u64>> for &'a BitFill<Block> type Slice = BitSliceAdapter<Self>;

• impl<'a, Block: BlockType> BitSliceable<RangeToInclusive<u64>> for &'a BitFill<Block> type Slice = BitSliceAdapter<Self>;

• impl<T: Bits, U: Bits<Block = T::Block>> BitSliceable<Range<u64>> for BitConcat<T, U> type Slice = BitSliceAdapter<Self>;

• impl<T: Bits, U: Bits<Block = T::Block>> BitSliceable<RangeFrom<u64>> for BitConcat<T, U> type Slice = BitSliceAdapter<Self>;

• impl<T: Bits, U: Bits<Block = T::Block>> BitSliceable<RangeTo<u64>> for BitConcat<T, U> type Slice = BitSliceAdapter<Self>;

• impl<T: Bits, U: Bits<Block = T::Block>> BitSliceable<RangeFull> for BitConcat<T, U> type Slice = BitSliceAdapter<Self>;

• impl<T: Bits, U: Bits<Block = T::Block>> BitSliceable<RangeInclusive<u64>> for BitConcat<T, U> type Slice = BitSliceAdapter<Self>;

• impl<T: Bits, U: Bits<Block = T::Block>> BitSliceable<RangeToInclusive<u64>> for BitConcat<T, U> type Slice = BitSliceAdapter<Self>;

• impl<'a, T: Bits, U: Bits<Block = T::Block>> BitSliceable<Range<u64>> for &'a BitConcat<T, U> type Slice = BitSliceAdapter<Self>;

• impl<'a, T: Bits, U: Bits<Block = T::Block>> BitSliceable<RangeFrom<u64>> for &'a BitConcat<T, U> type Slice = BitSliceAdapter<Self>;

• impl<'a, T: Bits, U: Bits<Block = T::Block>> BitSliceable<RangeTo<u64>> for &'a BitConcat<T, U> type Slice = BitSliceAdapter<Self>;

• impl<'a, T: Bits, U: Bits<Block = T::Block>> BitSliceable<RangeFull> for &'a BitConcat<T, U> type Slice = BitSliceAdapter<Self>;

• impl<'a, T: Bits, U: Bits<Block = T::Block>> BitSliceable<RangeInclusive<u64>> for &'a BitConcat<T, U> type Slice = BitSliceAdapter<Self>;

• impl<'a, T: Bits, U: Bits<Block = T::Block>> BitSliceable<RangeToInclusive<u64>> for &'a BitConcat<T, U> type Slice = BitSliceAdapter<Self>;