Trait bv::BitSliceable

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

Types that support slicing by ranges.

Note that the bit_slice method takes self by value, which allows the Slice associated type to refer to the lifetime of Self in impls for borrowed types. For example, the impl for &'a BitVec<u32> has a Slice type of BitSlice<'a, u32>.

Associated Types

type Slice: Bits<Block = Self::Block>

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> 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> BitSliceable<Range<u64>> for &'a [bool]

type Slice = &'a [bool]

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

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

type Slice = &'a mut [bool]

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

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

type Slice = &'a [bool]

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

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

type Slice = &'a mut [bool]

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

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

type Slice = &'a [bool]

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

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

type Slice = &'a mut [bool]

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

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

type Slice = &'a [bool]

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

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

type Slice = &'a mut [bool]

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

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

type Slice = &'a [bool]

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

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

type Slice = &'a mut [bool]

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

impl<'a, Block, R> BitSliceable<R> for &'a [Block] where
    Block: BlockType,
    BitSlice<'a, Block>: BitSliceable<R, Block = Block, Slice = BitSlice<'a, Block>>, 

type Slice = BitSlice<'a, Block>

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

impl<'a, Block, R> BitSliceable<R> for &'a mut [Block] where
    Block: BlockType,
    BitSliceMut<'a, Block>: BitSliceable<R, Block = Block, Slice = BitSliceMut<'a, Block>>, 

type Slice = BitSliceMut<'a, Block>

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

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

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, Block = u8>, 

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, Block = Block>, 

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, Block = u8>, 

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, Block = Block>, 

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, Block = u8>, 

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, Block = Block>, 

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, Block = u8>, 

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, Block = Block>, 

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, Block = u8>, 

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, Block = Block>, 

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, Block = u8>, 

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, Block = Block>, 

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, Block = u8>, 

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, Block = Block>, 

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, Block = u8>, 

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, Block = Block>, 

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, Block = u8>, 

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, Block = Block>, 

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, Block = u8>, 

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, Block = Block>, 

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, Block = u8>, 

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, Block = Block>, 

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, Block = u8>, 

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, Block = Block>, 

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, Block = u8>, 

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, Block = Block>, 

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, Block = u8>, 

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, Block = Block>, 

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, Block = u8>, 

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, Block = Block>, 

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, Block = u8>, 

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, Block = Block>, 

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, Block = u8>, 

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, Block = Block>, 

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, Block = u8>, 

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, Block = Block>, 

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, Block = u8>, 

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, Block = Block>, 

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, Block = u8>, 

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, Block = Block>, 

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, Block = u8>, 

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, Block = Block>, 

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, Block = u8>, 

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, Block = Block>, 

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, Block = u8>, 

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, Block = Block>, 

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, Block = u8>, 

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, Block = Block>, 

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, Block = u8>, 

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, Block = Block>, 

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, Block = u8>, 

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, Block = Block>, 

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, Block = u8>, 

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, Block = Block>, 

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, Block = u8>, 

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, Block = Block>, 

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, Block = u8>, 

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, Block = Block>, 

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, Block = u8>, 

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, Block = Block>, 

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, Block = u8>, 

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, Block = Block>, 

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, Block = u8>, 

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; 32] where
    &'a [Block]: BitSliceable<R, Block = Block>, 

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

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

impl<'a, R> BitSliceable<R> for &'a [bool; 32] where
    &'a [bool]: BitSliceable<R, Block = u8>, 

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; 64] where
    &'a [Block]: BitSliceable<R, Block = Block>, 

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

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

impl<'a, R> BitSliceable<R> for &'a [bool; 64] where
    &'a [bool]: BitSliceable<R, Block = u8>, 

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; 128] where
    &'a [Block]: BitSliceable<R, Block = Block>, 

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

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

impl<'a, R> BitSliceable<R> for &'a [bool; 128] where
    &'a [bool]: BitSliceable<R, Block = u8>, 

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; 256] where
    &'a [Block]: BitSliceable<R, Block = Block>, 

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

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

impl<'a, R> BitSliceable<R> for &'a [bool; 256] where
    &'a [bool]: BitSliceable<R, Block = u8>, 

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; 512] where
    &'a [Block]: BitSliceable<R, Block = Block>, 

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

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

impl<'a, R> BitSliceable<R> for &'a [bool; 512] where
    &'a [bool]: BitSliceable<R, Block = u8>, 

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; 1024] where
    &'a [Block]: BitSliceable<R, Block = Block>, 

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

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

impl<'a, R> BitSliceable<R> for &'a [bool; 1024] where
    &'a [bool]: BitSliceable<R, Block = u8>, 

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; 2048] where
    &'a [Block]: BitSliceable<R, Block = Block>, 

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

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

impl<'a, R> BitSliceable<R> for &'a [bool; 2048] where
    &'a [bool]: BitSliceable<R, Block = u8>, 

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; 4096] where
    &'a [Block]: BitSliceable<R, Block = Block>, 

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

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

impl<'a, R> BitSliceable<R> for &'a [bool; 4096] where
    &'a [bool]: BitSliceable<R, Block = u8>, 

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; 8192] where
    &'a [Block]: BitSliceable<R, Block = Block>, 

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

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

impl<'a, R> BitSliceable<R> for &'a [bool; 8192] where
    &'a [bool]: BitSliceable<R, Block = u8>, 

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; 16384] where
    &'a [Block]: BitSliceable<R, Block = Block>, 

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

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

impl<'a, R> BitSliceable<R> for &'a [bool; 16384] where
    &'a [bool]: BitSliceable<R, Block = u8>, 

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; 32768] where
    &'a [Block]: BitSliceable<R, Block = Block>, 

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

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

impl<'a, R> BitSliceable<R> for &'a [bool; 32768] where
    &'a [bool]: BitSliceable<R, Block = u8>, 

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; 65536] where
    &'a [Block]: BitSliceable<R, Block = Block>, 

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

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

impl<'a, R> BitSliceable<R> for &'a [bool; 65536] where
    &'a [bool]: BitSliceable<R, Block = u8>, 

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; 131072] where
    &'a [Block]: BitSliceable<R, Block = Block>, 

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

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

impl<'a, R> BitSliceable<R> for &'a [bool; 131072] where
    &'a [bool]: BitSliceable<R, Block = u8>, 

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; 262144] where
    &'a [Block]: BitSliceable<R, Block = Block>, 

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

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

impl<'a, R> BitSliceable<R> for &'a [bool; 262144] where
    &'a [bool]: BitSliceable<R, Block = u8>, 

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; 524288] where
    &'a [Block]: BitSliceable<R, Block = Block>, 

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

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

impl<'a, R> BitSliceable<R> for &'a [bool; 524288] where
    &'a [bool]: BitSliceable<R, Block = u8>, 

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; 1048576] where
    &'a [Block]: BitSliceable<R, Block = Block>, 

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

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

impl<'a, R> BitSliceable<R> for &'a [bool; 1048576] where
    &'a [bool]: BitSliceable<R, Block = u8>, 

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 &'a BitFill<Block>

type Slice = BitSliceAdapter<Self>

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

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

type Slice = BitSlice<'a, Block>

fn bit_slice(self, range: Range<u64>) -> BitSlice<'a, Block>

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

type Slice = BitSliceMut<'a, Block>

fn bit_slice(self, range: Range<u64>) -> BitSliceMut<'a, Block>

impl<'a, Block: BlockType> BitSliceable<Range<u64>> for BitSlice<'a, Block>

type Slice = Self

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

impl<'a, Block: BlockType> BitSliceable<Range<u64>> for BitSliceMut<'a, Block>

type Slice = Self

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

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

type Slice = BitSliceAdapter<Self>

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

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

type Slice = BitSlice<'a, Block>

fn bit_slice(self, range: RangeFrom<u64>) -> BitSlice<'a, Block>

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

type Slice = BitSliceMut<'a, Block>

fn bit_slice(self, range: RangeFrom<u64>) -> BitSliceMut<'a, Block>

impl<'a, Block: BlockType> BitSliceable<RangeFrom<u64>> for BitSlice<'a, Block>

type Slice = Self

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

impl<'a, Block: BlockType> BitSliceable<RangeFrom<u64>> for BitSliceMut<'a, Block>

type Slice = Self

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

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

type Slice = BitSliceAdapter<Self>

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

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

type Slice = BitSlice<'a, Block>

fn bit_slice(self, _: RangeFull) -> BitSlice<'a, Block>

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

type Slice = BitSliceMut<'a, Block>

fn bit_slice(self, _: RangeFull) -> BitSliceMut<'a, Block>

impl<'a, Block: BlockType> BitSliceable<RangeFull> for BitSlice<'a, Block>

type Slice = Self

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

impl<'a, Block: BlockType> BitSliceable<RangeFull> for BitSliceMut<'a, Block>

type Slice = Self

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

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

type Slice = BitSliceAdapter<Self>

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

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

type Slice = BitSlice<'a, Block>

fn bit_slice(self, range: RangeInclusive<u64>) -> BitSlice<'a, Block>

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

type Slice = BitSliceMut<'a, Block>

fn bit_slice(self, range: RangeInclusive<u64>) -> BitSliceMut<'a, Block>

impl<'a, Block: BlockType> BitSliceable<RangeInclusive<u64>> for BitSlice<'a, Block>

type Slice = Self

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

impl<'a, Block: BlockType> BitSliceable<RangeInclusive<u64>> for BitSliceMut<'a, Block>

type Slice = Self

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

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

type Slice = BitSliceAdapter<Self>

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

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

type Slice = BitSlice<'a, Block>

fn bit_slice(self, range: RangeTo<u64>) -> BitSlice<'a, Block>

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

type Slice = BitSliceMut<'a, Block>

fn bit_slice(self, range: RangeTo<u64>) -> BitSliceMut<'a, Block>

impl<'a, Block: BlockType> BitSliceable<RangeTo<u64>> for BitSlice<'a, Block>

type Slice = Self

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

impl<'a, Block: BlockType> BitSliceable<RangeTo<u64>> for BitSliceMut<'a, Block>

type Slice = Self

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

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

type Slice = BitSliceAdapter<Self>

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

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

type Slice = BitSlice<'a, Block>

fn bit_slice(self, range: RangeToInclusive<u64>) -> BitSlice<'a, Block>

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

type Slice = BitSliceMut<'a, Block>

fn bit_slice(self, range: RangeToInclusive<u64>) -> BitSliceMut<'a, Block>

impl<'a, Block: BlockType> BitSliceable<RangeToInclusive<u64>> for BitSlice<'a, Block>

type Slice = Self

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

impl<'a, Block: BlockType> BitSliceable<RangeToInclusive<u64>> for BitSliceMut<'a, Block>

type Slice = Self

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

impl<'a, T: Bits> BitSliceable<Range<u64>> for &'a BitNot<T>

type Slice = BitSliceAdapter<Self>

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

impl<'a, T: Bits> BitSliceable<Range<u64>> for &'a BitSliceAdapter<T>

type Slice = BitSliceAdapter<&'a T>

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

impl<'a, T: Bits> BitSliceable<RangeFrom<u64>> for &'a BitNot<T>

type Slice = BitSliceAdapter<Self>

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

impl<'a, T: Bits> BitSliceable<RangeFrom<u64>> for &'a BitSliceAdapter<T>

type Slice = BitSliceAdapter<&'a T>

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

impl<'a, T: Bits> BitSliceable<RangeFull> for &'a BitNot<T>

type Slice = BitSliceAdapter<Self>

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

impl<'a, T: Bits> BitSliceable<RangeFull> for &'a BitSliceAdapter<T>

type Slice = BitSliceAdapter<&'a T>

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

impl<'a, T: Bits> BitSliceable<RangeInclusive<u64>> for &'a BitNot<T>

type Slice = BitSliceAdapter<Self>

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

impl<'a, T: Bits> BitSliceable<RangeInclusive<u64>> for &'a BitSliceAdapter<T>

type Slice = BitSliceAdapter<&'a T>

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

impl<'a, T: Bits> BitSliceable<RangeTo<u64>> for &'a BitNot<T>

type Slice = BitSliceAdapter<Self>

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

impl<'a, T: Bits> BitSliceable<RangeTo<u64>> for &'a BitSliceAdapter<T>

type Slice = BitSliceAdapter<&'a T>

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

impl<'a, T: Bits> BitSliceable<RangeToInclusive<u64>> for &'a BitNot<T>

type Slice = BitSliceAdapter<Self>

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

impl<'a, T: Bits> BitSliceable<RangeToInclusive<u64>> for &'a BitSliceAdapter<T>

type Slice = BitSliceAdapter<&'a T>

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

impl<'a, T: Bits, U: Bits<Block = T::Block>> BitSliceable<Range<u64>> for &'a BitAnd<T, U>

type Slice = BitSliceAdapter<Self>

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

impl<'a, T: Bits, U: Bits<Block = T::Block>> BitSliceable<Range<u64>> for &'a BitConcat<T, U>

type Slice = BitSliceAdapter<Self>

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

impl<'a, T: Bits, U: Bits<Block = T::Block>> BitSliceable<Range<u64>> for &'a BitOr<T, U>

type Slice = BitSliceAdapter<Self>

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

impl<'a, T: Bits, U: Bits<Block = T::Block>> BitSliceable<Range<u64>> for &'a BitXor<T, U>

type Slice = BitSliceAdapter<Self>

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

impl<'a, T: Bits, U: Bits<Block = T::Block>> BitSliceable<RangeFrom<u64>> for &'a BitAnd<T, U>

type Slice = BitSliceAdapter<Self>

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

impl<'a, T: Bits, U: Bits<Block = T::Block>> BitSliceable<RangeFrom<u64>> for &'a BitConcat<T, U>

type Slice = BitSliceAdapter<Self>

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

impl<'a, T: Bits, U: Bits<Block = T::Block>> BitSliceable<RangeFrom<u64>> for &'a BitOr<T, U>

type Slice = BitSliceAdapter<Self>

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

impl<'a, T: Bits, U: Bits<Block = T::Block>> BitSliceable<RangeFrom<u64>> for &'a BitXor<T, U>

type Slice = BitSliceAdapter<Self>

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

impl<'a, T: Bits, U: Bits<Block = T::Block>> BitSliceable<RangeFull> for &'a BitAnd<T, U>

type Slice = BitSliceAdapter<Self>

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

impl<'a, T: Bits, U: Bits<Block = T::Block>> BitSliceable<RangeFull> for &'a BitConcat<T, U>

type Slice = BitSliceAdapter<Self>

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

impl<'a, T: Bits, U: Bits<Block = T::Block>> BitSliceable<RangeFull> for &'a BitOr<T, U>

type Slice = BitSliceAdapter<Self>

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

impl<'a, T: Bits, U: Bits<Block = T::Block>> BitSliceable<RangeFull> for &'a BitXor<T, U>

type Slice = BitSliceAdapter<Self>

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

impl<'a, T: Bits, U: Bits<Block = T::Block>> BitSliceable<RangeInclusive<u64>> for &'a BitAnd<T, U>

type Slice = BitSliceAdapter<Self>

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

impl<'a, T: Bits, U: Bits<Block = T::Block>> BitSliceable<RangeInclusive<u64>> for &'a BitConcat<T, U>

type Slice = BitSliceAdapter<Self>

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

impl<'a, T: Bits, U: Bits<Block = T::Block>> BitSliceable<RangeInclusive<u64>> for &'a BitOr<T, U>

type Slice = BitSliceAdapter<Self>

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

impl<'a, T: Bits, U: Bits<Block = T::Block>> BitSliceable<RangeInclusive<u64>> for &'a BitXor<T, U>

type Slice = BitSliceAdapter<Self>

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

impl<'a, T: Bits, U: Bits<Block = T::Block>> BitSliceable<RangeTo<u64>> for &'a BitAnd<T, U>

type Slice = BitSliceAdapter<Self>

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

impl<'a, T: Bits, U: Bits<Block = T::Block>> BitSliceable<RangeTo<u64>> for &'a BitConcat<T, U>

type Slice = BitSliceAdapter<Self>

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

impl<'a, T: Bits, U: Bits<Block = T::Block>> BitSliceable<RangeTo<u64>> for &'a BitOr<T, U>

type Slice = BitSliceAdapter<Self>

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

impl<'a, T: Bits, U: Bits<Block = T::Block>> BitSliceable<RangeTo<u64>> for &'a BitXor<T, U>

type Slice = BitSliceAdapter<Self>

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

impl<'a, T: Bits, U: Bits<Block = T::Block>> BitSliceable<RangeToInclusive<u64>> for &'a BitAnd<T, U>

type Slice = BitSliceAdapter<Self>

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

impl<'a, T: Bits, U: Bits<Block = T::Block>> BitSliceable<RangeToInclusive<u64>> for &'a BitConcat<T, U>

type Slice = BitSliceAdapter<Self>

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

impl<'a, T: Bits, U: Bits<Block = T::Block>> BitSliceable<RangeToInclusive<u64>> for &'a BitOr<T, U>

type Slice = BitSliceAdapter<Self>

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

impl<'a, T: Bits, U: Bits<Block = T::Block>> BitSliceable<RangeToInclusive<u64>> for &'a BitXor<T, U>

type Slice = BitSliceAdapter<Self>

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

impl<'a, T: Bits, U: Bits<Block = T::Block>, F: Fn(T::Block, T::Block) -> T::Block> BitSliceable<Range<u64>> for &'a BitZip<T, U, F>

type Slice = BitSliceAdapter<Self>

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

impl<'a, T: Bits, U: Bits<Block = T::Block>, F: Fn(T::Block, T::Block) -> T::Block> BitSliceable<RangeFrom<u64>> for &'a BitZip<T, U, F>

type Slice = BitSliceAdapter<Self>

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

impl<'a, T: Bits, U: Bits<Block = T::Block>, F: Fn(T::Block, T::Block) -> T::Block> BitSliceable<RangeFull> for &'a BitZip<T, U, F>

type Slice = BitSliceAdapter<Self>

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

impl<'a, T: Bits, U: Bits<Block = T::Block>, F: Fn(T::Block, T::Block) -> T::Block> BitSliceable<RangeInclusive<u64>> for &'a BitZip<T, U, F>

type Slice = BitSliceAdapter<Self>

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

impl<'a, T: Bits, U: Bits<Block = T::Block>, F: Fn(T::Block, T::Block) -> T::Block> BitSliceable<RangeTo<u64>> for &'a BitZip<T, U, F>

type Slice = BitSliceAdapter<Self>

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

impl<'a, T: Bits, U: Bits<Block = T::Block>, F: Fn(T::Block, T::Block) -> T::Block> BitSliceable<RangeToInclusive<u64>> for &'a BitZip<T, U, F>

type Slice = BitSliceAdapter<Self>

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

impl<Block, R, T, U> BitSliceable<R> for BitAnd<T, U> where
    Block: BlockType,
    R: Clone,
    T: BitSliceable<R, Block = Block>,
    U: BitSliceable<R, Block = Block>, 

type Slice = BitAnd<T::Slice, U::Slice>

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

impl<Block, R, T, U> BitSliceable<R> for BitOr<T, U> where
    Block: BlockType,
    R: Clone,
    T: BitSliceable<R, Block = Block>,
    U: BitSliceable<R, Block = Block>, 

type Slice = BitOr<T::Slice, U::Slice>

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

impl<Block, R, T, U> BitSliceable<R> for BitXor<T, U> where
    Block: BlockType,
    R: Clone,
    T: BitSliceable<R, Block = Block>,
    U: BitSliceable<R, Block = Block>, 

type Slice = BitXor<T::Slice, U::Slice>

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

impl<Block, R, T, U, F> BitSliceable<R> for BitZip<T, U, F> where
    Block: BlockType,
    R: Clone,
    T: BitSliceable<R, Block = Block>,
    U: BitSliceable<R, Block = Block>,
    F: Fn(Block, Block) -> Block, 

type Slice = BitZip<T::Slice, U::Slice, F>

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

impl<Block: BlockType> BitSliceable<Range<u64>> for BitFill<Block>

type Slice = BitSliceAdapter<Self>

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

impl<Block: BlockType> BitSliceable<RangeFrom<u64>> for BitFill<Block>

type Slice = BitSliceAdapter<Self>

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

impl<Block: BlockType> BitSliceable<RangeFull> for BitFill<Block>

type Slice = BitSliceAdapter<Self>

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

impl<Block: BlockType> BitSliceable<RangeInclusive<u64>> for BitFill<Block>

type Slice = BitSliceAdapter<Self>

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

impl<Block: BlockType> BitSliceable<RangeTo<u64>> for BitFill<Block>

type Slice = BitSliceAdapter<Self>

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

impl<Block: BlockType> BitSliceable<RangeToInclusive<u64>> for BitFill<Block>

type Slice = BitSliceAdapter<Self>

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

impl<R, T> BitSliceable<R> for BitNot<T> where
    T: BitSliceable<R>, 

type Slice = BitNot<T::Slice>

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

impl<T: Bits> BitSliceable<Range<u64>> for BitSliceAdapter<T>

type Slice = Self

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

impl<T: Bits> BitSliceable<RangeFrom<u64>> for BitSliceAdapter<T>

type Slice = Self

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

impl<T: Bits> BitSliceable<RangeFull> for BitSliceAdapter<T>

type Slice = Self

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

impl<T: Bits> BitSliceable<RangeInclusive<u64>> for BitSliceAdapter<T>

type Slice = Self

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

impl<T: Bits> BitSliceable<RangeTo<u64>> for BitSliceAdapter<T>

type Slice = Self

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

impl<T: Bits> BitSliceable<RangeToInclusive<u64>> for BitSliceAdapter<T>

type Slice = Self

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

impl<T: Bits, U: Bits<Block = T::Block>> BitSliceable<Range<u64>> for BitConcat<T, U>

type Slice = BitSliceAdapter<Self>

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

impl<T: Bits, U: Bits<Block = T::Block>> BitSliceable<RangeFrom<u64>> for BitConcat<T, U>

type Slice = BitSliceAdapter<Self>

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

impl<T: Bits, U: Bits<Block = T::Block>> BitSliceable<RangeFull> for BitConcat<T, U>

type Slice = BitSliceAdapter<Self>

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

impl<T: Bits, U: Bits<Block = T::Block>> BitSliceable<RangeInclusive<u64>> for BitConcat<T, U>

type Slice = BitSliceAdapter<Self>

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

impl<T: Bits, U: Bits<Block = T::Block>> BitSliceable<RangeTo<u64>> for BitConcat<T, U>

type Slice = BitSliceAdapter<Self>

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

impl<T: Bits, U: Bits<Block = T::Block>> BitSliceable<RangeToInclusive<u64>> for BitConcat<T, U>

type Slice = BitSliceAdapter<Self>

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