Trait Bits

pub trait Bits<T> {
    // Required method
    fn bits<const START: usize, const END: usize>(&self) -> T;
}

Read a range of bits inside a value.

Required Methods

fn bits<const START: usize, const END: usize>(&self) -> T

Read self’s START..END bit range (with END excluded) as a value of type T.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl Bits<i8> for i8

fn bits<const START: usize, const END: usize>(&self) -> i8

impl Bits<i8> for i16

fn bits<const START: usize, const END: usize>(&self) -> i8

impl Bits<i8> for i32

fn bits<const START: usize, const END: usize>(&self) -> i8

impl Bits<i8> for i64

fn bits<const START: usize, const END: usize>(&self) -> i8

impl Bits<i8> for i128

fn bits<const START: usize, const END: usize>(&self) -> i8

impl Bits<i8> for isize

fn bits<const START: usize, const END: usize>(&self) -> i8

impl Bits<i8> for u8

fn bits<const START: usize, const END: usize>(&self) -> i8

impl Bits<i8> for u16

fn bits<const START: usize, const END: usize>(&self) -> i8

impl Bits<i8> for u32

fn bits<const START: usize, const END: usize>(&self) -> i8

impl Bits<i8> for u64

fn bits<const START: usize, const END: usize>(&self) -> i8

impl Bits<i8> for u128

fn bits<const START: usize, const END: usize>(&self) -> i8

impl Bits<i8> for usize

fn bits<const START: usize, const END: usize>(&self) -> i8

impl Bits<i8> for [i8]

fn bits<const START: usize, const END: usize>(&self) -> i8

impl Bits<i8> for [i16]

fn bits<const START: usize, const END: usize>(&self) -> i8

impl Bits<i8> for [i32]

fn bits<const START: usize, const END: usize>(&self) -> i8

impl Bits<i8> for [i64]

fn bits<const START: usize, const END: usize>(&self) -> i8

impl Bits<i8> for [i128]

fn bits<const START: usize, const END: usize>(&self) -> i8

impl Bits<i8> for [isize]

fn bits<const START: usize, const END: usize>(&self) -> i8

impl Bits<i8> for [u8]

fn bits<const START: usize, const END: usize>(&self) -> i8

impl Bits<i8> for [u16]

fn bits<const START: usize, const END: usize>(&self) -> i8

impl Bits<i8> for [u32]

fn bits<const START: usize, const END: usize>(&self) -> i8

impl Bits<i8> for [u64]

fn bits<const START: usize, const END: usize>(&self) -> i8

impl Bits<i8> for [u128]

fn bits<const START: usize, const END: usize>(&self) -> i8

impl Bits<i8> for [usize]

fn bits<const START: usize, const END: usize>(&self) -> i8

impl Bits<i16> for i8

fn bits<const START: usize, const END: usize>(&self) -> i16

impl Bits<i16> for i16

fn bits<const START: usize, const END: usize>(&self) -> i16

impl Bits<i16> for i32

fn bits<const START: usize, const END: usize>(&self) -> i16

impl Bits<i16> for i64

fn bits<const START: usize, const END: usize>(&self) -> i16

impl Bits<i16> for i128

fn bits<const START: usize, const END: usize>(&self) -> i16

impl Bits<i16> for isize

fn bits<const START: usize, const END: usize>(&self) -> i16

impl Bits<i16> for u8

fn bits<const START: usize, const END: usize>(&self) -> i16

impl Bits<i16> for u16

fn bits<const START: usize, const END: usize>(&self) -> i16

impl Bits<i16> for u32

fn bits<const START: usize, const END: usize>(&self) -> i16

impl Bits<i16> for u64

fn bits<const START: usize, const END: usize>(&self) -> i16

impl Bits<i16> for u128

fn bits<const START: usize, const END: usize>(&self) -> i16

impl Bits<i16> for usize

fn bits<const START: usize, const END: usize>(&self) -> i16

impl Bits<i16> for [i8]

fn bits<const START: usize, const END: usize>(&self) -> i16

impl Bits<i16> for [i16]

fn bits<const START: usize, const END: usize>(&self) -> i16

impl Bits<i16> for [i32]

fn bits<const START: usize, const END: usize>(&self) -> i16

impl Bits<i16> for [i64]

fn bits<const START: usize, const END: usize>(&self) -> i16

impl Bits<i16> for [i128]

fn bits<const START: usize, const END: usize>(&self) -> i16

impl Bits<i16> for [isize]

fn bits<const START: usize, const END: usize>(&self) -> i16

impl Bits<i16> for [u8]

fn bits<const START: usize, const END: usize>(&self) -> i16

impl Bits<i16> for [u16]

fn bits<const START: usize, const END: usize>(&self) -> i16

impl Bits<i16> for [u32]

fn bits<const START: usize, const END: usize>(&self) -> i16

impl Bits<i16> for [u64]

fn bits<const START: usize, const END: usize>(&self) -> i16

impl Bits<i16> for [u128]

fn bits<const START: usize, const END: usize>(&self) -> i16

impl Bits<i16> for [usize]

fn bits<const START: usize, const END: usize>(&self) -> i16

impl Bits<i32> for i8

fn bits<const START: usize, const END: usize>(&self) -> i32

impl Bits<i32> for i16

fn bits<const START: usize, const END: usize>(&self) -> i32

impl Bits<i32> for i32

fn bits<const START: usize, const END: usize>(&self) -> i32

impl Bits<i32> for i64

fn bits<const START: usize, const END: usize>(&self) -> i32

impl Bits<i32> for i128

fn bits<const START: usize, const END: usize>(&self) -> i32

impl Bits<i32> for isize

fn bits<const START: usize, const END: usize>(&self) -> i32

impl Bits<i32> for u8

fn bits<const START: usize, const END: usize>(&self) -> i32

impl Bits<i32> for u16

fn bits<const START: usize, const END: usize>(&self) -> i32

impl Bits<i32> for u32

fn bits<const START: usize, const END: usize>(&self) -> i32

impl Bits<i32> for u64

fn bits<const START: usize, const END: usize>(&self) -> i32

impl Bits<i32> for u128

fn bits<const START: usize, const END: usize>(&self) -> i32

impl Bits<i32> for usize

fn bits<const START: usize, const END: usize>(&self) -> i32

impl Bits<i32> for [i8]

fn bits<const START: usize, const END: usize>(&self) -> i32

impl Bits<i32> for [i16]

fn bits<const START: usize, const END: usize>(&self) -> i32

impl Bits<i32> for [i32]

fn bits<const START: usize, const END: usize>(&self) -> i32

impl Bits<i32> for [i64]

fn bits<const START: usize, const END: usize>(&self) -> i32

impl Bits<i32> for [i128]

fn bits<const START: usize, const END: usize>(&self) -> i32

impl Bits<i32> for [isize]

fn bits<const START: usize, const END: usize>(&self) -> i32

impl Bits<i32> for [u8]

fn bits<const START: usize, const END: usize>(&self) -> i32

impl Bits<i32> for [u16]

fn bits<const START: usize, const END: usize>(&self) -> i32

impl Bits<i32> for [u32]

fn bits<const START: usize, const END: usize>(&self) -> i32

impl Bits<i32> for [u64]

fn bits<const START: usize, const END: usize>(&self) -> i32

impl Bits<i32> for [u128]

fn bits<const START: usize, const END: usize>(&self) -> i32

impl Bits<i32> for [usize]

fn bits<const START: usize, const END: usize>(&self) -> i32

impl Bits<i64> for i8

fn bits<const START: usize, const END: usize>(&self) -> i64

impl Bits<i64> for i16

fn bits<const START: usize, const END: usize>(&self) -> i64

impl Bits<i64> for i32

fn bits<const START: usize, const END: usize>(&self) -> i64

impl Bits<i64> for i64

fn bits<const START: usize, const END: usize>(&self) -> i64

impl Bits<i64> for i128

fn bits<const START: usize, const END: usize>(&self) -> i64

impl Bits<i64> for isize

fn bits<const START: usize, const END: usize>(&self) -> i64

impl Bits<i64> for u8

fn bits<const START: usize, const END: usize>(&self) -> i64

impl Bits<i64> for u16

fn bits<const START: usize, const END: usize>(&self) -> i64

impl Bits<i64> for u32

fn bits<const START: usize, const END: usize>(&self) -> i64

impl Bits<i64> for u64

fn bits<const START: usize, const END: usize>(&self) -> i64

impl Bits<i64> for u128

fn bits<const START: usize, const END: usize>(&self) -> i64

impl Bits<i64> for usize

fn bits<const START: usize, const END: usize>(&self) -> i64

impl Bits<i64> for [i8]

fn bits<const START: usize, const END: usize>(&self) -> i64

impl Bits<i64> for [i16]

fn bits<const START: usize, const END: usize>(&self) -> i64

impl Bits<i64> for [i32]

fn bits<const START: usize, const END: usize>(&self) -> i64

impl Bits<i64> for [i64]

fn bits<const START: usize, const END: usize>(&self) -> i64

impl Bits<i64> for [i128]

fn bits<const START: usize, const END: usize>(&self) -> i64

impl Bits<i64> for [isize]

fn bits<const START: usize, const END: usize>(&self) -> i64

impl Bits<i64> for [u8]

fn bits<const START: usize, const END: usize>(&self) -> i64

impl Bits<i64> for [u16]

fn bits<const START: usize, const END: usize>(&self) -> i64

impl Bits<i64> for [u32]

fn bits<const START: usize, const END: usize>(&self) -> i64

impl Bits<i64> for [u64]

fn bits<const START: usize, const END: usize>(&self) -> i64

impl Bits<i64> for [u128]

fn bits<const START: usize, const END: usize>(&self) -> i64

impl Bits<i64> for [usize]

fn bits<const START: usize, const END: usize>(&self) -> i64

impl Bits<i128> for i8

fn bits<const START: usize, const END: usize>(&self) -> i128

impl Bits<i128> for i16

fn bits<const START: usize, const END: usize>(&self) -> i128

impl Bits<i128> for i32

fn bits<const START: usize, const END: usize>(&self) -> i128

impl Bits<i128> for i64

fn bits<const START: usize, const END: usize>(&self) -> i128

impl Bits<i128> for i128

fn bits<const START: usize, const END: usize>(&self) -> i128

impl Bits<i128> for isize

fn bits<const START: usize, const END: usize>(&self) -> i128

impl Bits<i128> for u8

fn bits<const START: usize, const END: usize>(&self) -> i128

impl Bits<i128> for u16

fn bits<const START: usize, const END: usize>(&self) -> i128

impl Bits<i128> for u32

fn bits<const START: usize, const END: usize>(&self) -> i128

impl Bits<i128> for u64

fn bits<const START: usize, const END: usize>(&self) -> i128

impl Bits<i128> for u128

fn bits<const START: usize, const END: usize>(&self) -> i128

impl Bits<i128> for usize

fn bits<const START: usize, const END: usize>(&self) -> i128

impl Bits<i128> for [i8]

fn bits<const START: usize, const END: usize>(&self) -> i128

impl Bits<i128> for [i16]

fn bits<const START: usize, const END: usize>(&self) -> i128

impl Bits<i128> for [i32]

fn bits<const START: usize, const END: usize>(&self) -> i128

impl Bits<i128> for [i64]

fn bits<const START: usize, const END: usize>(&self) -> i128

impl Bits<i128> for [i128]

fn bits<const START: usize, const END: usize>(&self) -> i128

impl Bits<i128> for [isize]

fn bits<const START: usize, const END: usize>(&self) -> i128

impl Bits<i128> for [u8]

fn bits<const START: usize, const END: usize>(&self) -> i128

impl Bits<i128> for [u16]

fn bits<const START: usize, const END: usize>(&self) -> i128

impl Bits<i128> for [u32]

fn bits<const START: usize, const END: usize>(&self) -> i128

impl Bits<i128> for [u64]

fn bits<const START: usize, const END: usize>(&self) -> i128

impl Bits<i128> for [u128]

fn bits<const START: usize, const END: usize>(&self) -> i128

impl Bits<i128> for [usize]

fn bits<const START: usize, const END: usize>(&self) -> i128

impl Bits<isize> for i8

fn bits<const START: usize, const END: usize>(&self) -> isize

impl Bits<isize> for i16

fn bits<const START: usize, const END: usize>(&self) -> isize

impl Bits<isize> for i32

fn bits<const START: usize, const END: usize>(&self) -> isize

impl Bits<isize> for i64

fn bits<const START: usize, const END: usize>(&self) -> isize

impl Bits<isize> for i128

fn bits<const START: usize, const END: usize>(&self) -> isize

impl Bits<isize> for isize

fn bits<const START: usize, const END: usize>(&self) -> isize

impl Bits<isize> for u8

fn bits<const START: usize, const END: usize>(&self) -> isize

impl Bits<isize> for u16

fn bits<const START: usize, const END: usize>(&self) -> isize

impl Bits<isize> for u32

fn bits<const START: usize, const END: usize>(&self) -> isize

impl Bits<isize> for u64

fn bits<const START: usize, const END: usize>(&self) -> isize

impl Bits<isize> for u128

fn bits<const START: usize, const END: usize>(&self) -> isize

impl Bits<isize> for usize

fn bits<const START: usize, const END: usize>(&self) -> isize

impl Bits<isize> for [i8]

fn bits<const START: usize, const END: usize>(&self) -> isize

impl Bits<isize> for [i16]

fn bits<const START: usize, const END: usize>(&self) -> isize

impl Bits<isize> for [i32]

fn bits<const START: usize, const END: usize>(&self) -> isize

impl Bits<isize> for [i64]

fn bits<const START: usize, const END: usize>(&self) -> isize

impl Bits<isize> for [i128]

fn bits<const START: usize, const END: usize>(&self) -> isize

impl Bits<isize> for [isize]

fn bits<const START: usize, const END: usize>(&self) -> isize

impl Bits<isize> for [u8]

fn bits<const START: usize, const END: usize>(&self) -> isize

impl Bits<isize> for [u16]

fn bits<const START: usize, const END: usize>(&self) -> isize

impl Bits<isize> for [u32]

fn bits<const START: usize, const END: usize>(&self) -> isize

impl Bits<isize> for [u64]

fn bits<const START: usize, const END: usize>(&self) -> isize

impl Bits<isize> for [u128]

fn bits<const START: usize, const END: usize>(&self) -> isize

impl Bits<isize> for [usize]

fn bits<const START: usize, const END: usize>(&self) -> isize

impl Bits<u8> for i8

fn bits<const START: usize, const END: usize>(&self) -> u8

impl Bits<u8> for i16

fn bits<const START: usize, const END: usize>(&self) -> u8

impl Bits<u8> for i32

fn bits<const START: usize, const END: usize>(&self) -> u8

impl Bits<u8> for i64

fn bits<const START: usize, const END: usize>(&self) -> u8

impl Bits<u8> for i128

fn bits<const START: usize, const END: usize>(&self) -> u8

impl Bits<u8> for isize

fn bits<const START: usize, const END: usize>(&self) -> u8

impl Bits<u8> for u8

fn bits<const START: usize, const END: usize>(&self) -> u8

impl Bits<u8> for u16

fn bits<const START: usize, const END: usize>(&self) -> u8

impl Bits<u8> for u32

fn bits<const START: usize, const END: usize>(&self) -> u8

impl Bits<u8> for u64

fn bits<const START: usize, const END: usize>(&self) -> u8

impl Bits<u8> for u128

fn bits<const START: usize, const END: usize>(&self) -> u8

impl Bits<u8> for usize

fn bits<const START: usize, const END: usize>(&self) -> u8

impl Bits<u8> for [i8]

fn bits<const START: usize, const END: usize>(&self) -> u8

impl Bits<u8> for [i16]

fn bits<const START: usize, const END: usize>(&self) -> u8

impl Bits<u8> for [i32]

fn bits<const START: usize, const END: usize>(&self) -> u8

impl Bits<u8> for [i64]

fn bits<const START: usize, const END: usize>(&self) -> u8

impl Bits<u8> for [i128]

fn bits<const START: usize, const END: usize>(&self) -> u8

impl Bits<u8> for [isize]

fn bits<const START: usize, const END: usize>(&self) -> u8

impl Bits<u8> for [u8]

fn bits<const START: usize, const END: usize>(&self) -> u8

impl Bits<u8> for [u16]

fn bits<const START: usize, const END: usize>(&self) -> u8

impl Bits<u8> for [u32]

fn bits<const START: usize, const END: usize>(&self) -> u8

impl Bits<u8> for [u64]

fn bits<const START: usize, const END: usize>(&self) -> u8

impl Bits<u8> for [u128]

fn bits<const START: usize, const END: usize>(&self) -> u8

impl Bits<u8> for [usize]

fn bits<const START: usize, const END: usize>(&self) -> u8

impl Bits<u16> for i8

fn bits<const START: usize, const END: usize>(&self) -> u16

impl Bits<u16> for i16

fn bits<const START: usize, const END: usize>(&self) -> u16

impl Bits<u16> for i32

fn bits<const START: usize, const END: usize>(&self) -> u16

impl Bits<u16> for i64

fn bits<const START: usize, const END: usize>(&self) -> u16

impl Bits<u16> for i128

fn bits<const START: usize, const END: usize>(&self) -> u16

impl Bits<u16> for isize

fn bits<const START: usize, const END: usize>(&self) -> u16

impl Bits<u16> for u8

fn bits<const START: usize, const END: usize>(&self) -> u16

impl Bits<u16> for u16

fn bits<const START: usize, const END: usize>(&self) -> u16

impl Bits<u16> for u32

fn bits<const START: usize, const END: usize>(&self) -> u16

impl Bits<u16> for u64

fn bits<const START: usize, const END: usize>(&self) -> u16

impl Bits<u16> for u128

fn bits<const START: usize, const END: usize>(&self) -> u16

impl Bits<u16> for usize

fn bits<const START: usize, const END: usize>(&self) -> u16

impl Bits<u16> for [i8]

fn bits<const START: usize, const END: usize>(&self) -> u16

impl Bits<u16> for [i16]

fn bits<const START: usize, const END: usize>(&self) -> u16

impl Bits<u16> for [i32]

fn bits<const START: usize, const END: usize>(&self) -> u16

impl Bits<u16> for [i64]

fn bits<const START: usize, const END: usize>(&self) -> u16

impl Bits<u16> for [i128]

fn bits<const START: usize, const END: usize>(&self) -> u16

impl Bits<u16> for [isize]

fn bits<const START: usize, const END: usize>(&self) -> u16

impl Bits<u16> for [u8]

fn bits<const START: usize, const END: usize>(&self) -> u16

impl Bits<u16> for [u16]

fn bits<const START: usize, const END: usize>(&self) -> u16

impl Bits<u16> for [u32]

fn bits<const START: usize, const END: usize>(&self) -> u16

impl Bits<u16> for [u64]

fn bits<const START: usize, const END: usize>(&self) -> u16

impl Bits<u16> for [u128]

fn bits<const START: usize, const END: usize>(&self) -> u16

impl Bits<u16> for [usize]

fn bits<const START: usize, const END: usize>(&self) -> u16

impl Bits<u32> for i8

fn bits<const START: usize, const END: usize>(&self) -> u32

impl Bits<u32> for i16

fn bits<const START: usize, const END: usize>(&self) -> u32

impl Bits<u32> for i32

fn bits<const START: usize, const END: usize>(&self) -> u32

impl Bits<u32> for i64

fn bits<const START: usize, const END: usize>(&self) -> u32

impl Bits<u32> for i128

fn bits<const START: usize, const END: usize>(&self) -> u32

impl Bits<u32> for isize

fn bits<const START: usize, const END: usize>(&self) -> u32

impl Bits<u32> for u8

fn bits<const START: usize, const END: usize>(&self) -> u32

impl Bits<u32> for u16

fn bits<const START: usize, const END: usize>(&self) -> u32

impl Bits<u32> for u32

fn bits<const START: usize, const END: usize>(&self) -> u32

impl Bits<u32> for u64

fn bits<const START: usize, const END: usize>(&self) -> u32

impl Bits<u32> for u128

fn bits<const START: usize, const END: usize>(&self) -> u32

impl Bits<u32> for usize

fn bits<const START: usize, const END: usize>(&self) -> u32

impl Bits<u32> for [i8]

fn bits<const START: usize, const END: usize>(&self) -> u32

impl Bits<u32> for [i16]

fn bits<const START: usize, const END: usize>(&self) -> u32

impl Bits<u32> for [i32]

fn bits<const START: usize, const END: usize>(&self) -> u32

impl Bits<u32> for [i64]

fn bits<const START: usize, const END: usize>(&self) -> u32

impl Bits<u32> for [i128]

fn bits<const START: usize, const END: usize>(&self) -> u32

impl Bits<u32> for [isize]

fn bits<const START: usize, const END: usize>(&self) -> u32

impl Bits<u32> for [u8]

fn bits<const START: usize, const END: usize>(&self) -> u32

impl Bits<u32> for [u16]

fn bits<const START: usize, const END: usize>(&self) -> u32

impl Bits<u32> for [u32]

fn bits<const START: usize, const END: usize>(&self) -> u32

impl Bits<u32> for [u64]

fn bits<const START: usize, const END: usize>(&self) -> u32

impl Bits<u32> for [u128]

fn bits<const START: usize, const END: usize>(&self) -> u32

impl Bits<u32> for [usize]

fn bits<const START: usize, const END: usize>(&self) -> u32

impl Bits<u64> for i8

fn bits<const START: usize, const END: usize>(&self) -> u64

impl Bits<u64> for i16

fn bits<const START: usize, const END: usize>(&self) -> u64

impl Bits<u64> for i32

fn bits<const START: usize, const END: usize>(&self) -> u64

impl Bits<u64> for i64

fn bits<const START: usize, const END: usize>(&self) -> u64

impl Bits<u64> for i128

fn bits<const START: usize, const END: usize>(&self) -> u64

impl Bits<u64> for isize

fn bits<const START: usize, const END: usize>(&self) -> u64

impl Bits<u64> for u8

fn bits<const START: usize, const END: usize>(&self) -> u64

impl Bits<u64> for u16

fn bits<const START: usize, const END: usize>(&self) -> u64

impl Bits<u64> for u32

fn bits<const START: usize, const END: usize>(&self) -> u64

impl Bits<u64> for u64

fn bits<const START: usize, const END: usize>(&self) -> u64

impl Bits<u64> for u128

fn bits<const START: usize, const END: usize>(&self) -> u64

impl Bits<u64> for usize

fn bits<const START: usize, const END: usize>(&self) -> u64

impl Bits<u64> for [i8]

fn bits<const START: usize, const END: usize>(&self) -> u64

impl Bits<u64> for [i16]

fn bits<const START: usize, const END: usize>(&self) -> u64

impl Bits<u64> for [i32]

fn bits<const START: usize, const END: usize>(&self) -> u64

impl Bits<u64> for [i64]

fn bits<const START: usize, const END: usize>(&self) -> u64

impl Bits<u64> for [i128]

fn bits<const START: usize, const END: usize>(&self) -> u64

impl Bits<u64> for [isize]

fn bits<const START: usize, const END: usize>(&self) -> u64

impl Bits<u64> for [u8]

fn bits<const START: usize, const END: usize>(&self) -> u64

impl Bits<u64> for [u16]

fn bits<const START: usize, const END: usize>(&self) -> u64

impl Bits<u64> for [u32]

fn bits<const START: usize, const END: usize>(&self) -> u64

impl Bits<u64> for [u64]

fn bits<const START: usize, const END: usize>(&self) -> u64

impl Bits<u64> for [u128]

fn bits<const START: usize, const END: usize>(&self) -> u64

impl Bits<u64> for [usize]

fn bits<const START: usize, const END: usize>(&self) -> u64

impl Bits<u128> for i8

fn bits<const START: usize, const END: usize>(&self) -> u128

impl Bits<u128> for i16

fn bits<const START: usize, const END: usize>(&self) -> u128

impl Bits<u128> for i32

fn bits<const START: usize, const END: usize>(&self) -> u128

impl Bits<u128> for i64

fn bits<const START: usize, const END: usize>(&self) -> u128

impl Bits<u128> for i128

fn bits<const START: usize, const END: usize>(&self) -> u128

impl Bits<u128> for isize

fn bits<const START: usize, const END: usize>(&self) -> u128

impl Bits<u128> for u8

fn bits<const START: usize, const END: usize>(&self) -> u128

impl Bits<u128> for u16

fn bits<const START: usize, const END: usize>(&self) -> u128

impl Bits<u128> for u32

fn bits<const START: usize, const END: usize>(&self) -> u128

impl Bits<u128> for u64

fn bits<const START: usize, const END: usize>(&self) -> u128

impl Bits<u128> for u128

fn bits<const START: usize, const END: usize>(&self) -> u128

impl Bits<u128> for usize

fn bits<const START: usize, const END: usize>(&self) -> u128

impl Bits<u128> for [i8]

fn bits<const START: usize, const END: usize>(&self) -> u128

impl Bits<u128> for [i16]

fn bits<const START: usize, const END: usize>(&self) -> u128

impl Bits<u128> for [i32]

fn bits<const START: usize, const END: usize>(&self) -> u128

impl Bits<u128> for [i64]

fn bits<const START: usize, const END: usize>(&self) -> u128

impl Bits<u128> for [i128]

fn bits<const START: usize, const END: usize>(&self) -> u128

impl Bits<u128> for [isize]

fn bits<const START: usize, const END: usize>(&self) -> u128

impl Bits<u128> for [u8]

fn bits<const START: usize, const END: usize>(&self) -> u128

impl Bits<u128> for [u16]

fn bits<const START: usize, const END: usize>(&self) -> u128

impl Bits<u128> for [u32]

fn bits<const START: usize, const END: usize>(&self) -> u128

impl Bits<u128> for [u64]

fn bits<const START: usize, const END: usize>(&self) -> u128

impl Bits<u128> for [u128]

fn bits<const START: usize, const END: usize>(&self) -> u128

impl Bits<u128> for [usize]

fn bits<const START: usize, const END: usize>(&self) -> u128

impl Bits<usize> for i8

fn bits<const START: usize, const END: usize>(&self) -> usize

impl Bits<usize> for i16

fn bits<const START: usize, const END: usize>(&self) -> usize

impl Bits<usize> for i32

fn bits<const START: usize, const END: usize>(&self) -> usize

impl Bits<usize> for i64

fn bits<const START: usize, const END: usize>(&self) -> usize

impl Bits<usize> for i128

fn bits<const START: usize, const END: usize>(&self) -> usize

impl Bits<usize> for isize

fn bits<const START: usize, const END: usize>(&self) -> usize

impl Bits<usize> for u8

fn bits<const START: usize, const END: usize>(&self) -> usize

impl Bits<usize> for u16

fn bits<const START: usize, const END: usize>(&self) -> usize

impl Bits<usize> for u32

fn bits<const START: usize, const END: usize>(&self) -> usize

impl Bits<usize> for u64

fn bits<const START: usize, const END: usize>(&self) -> usize

impl Bits<usize> for u128

fn bits<const START: usize, const END: usize>(&self) -> usize

impl Bits<usize> for usize

fn bits<const START: usize, const END: usize>(&self) -> usize

impl Bits<usize> for [i8]

fn bits<const START: usize, const END: usize>(&self) -> usize

impl Bits<usize> for [i16]

fn bits<const START: usize, const END: usize>(&self) -> usize

impl Bits<usize> for [i32]

fn bits<const START: usize, const END: usize>(&self) -> usize

impl Bits<usize> for [i64]

fn bits<const START: usize, const END: usize>(&self) -> usize

impl Bits<usize> for [i128]

fn bits<const START: usize, const END: usize>(&self) -> usize

impl Bits<usize> for [isize]

fn bits<const START: usize, const END: usize>(&self) -> usize

impl Bits<usize> for [u8]

fn bits<const START: usize, const END: usize>(&self) -> usize

impl Bits<usize> for [u16]

fn bits<const START: usize, const END: usize>(&self) -> usize

impl Bits<usize> for [u32]

fn bits<const START: usize, const END: usize>(&self) -> usize

impl Bits<usize> for [u64]

fn bits<const START: usize, const END: usize>(&self) -> usize

impl Bits<usize> for [u128]

fn bits<const START: usize, const END: usize>(&self) -> usize

impl Bits<usize> for [usize]

fn bits<const START: usize, const END: usize>(&self) -> usize

impl Bits<UnwrapBitsExample> for i8

where UnwrapBitsExample: TryFrom<i8> + Into<i8>, <UnwrapBitsExample as TryFrom<i8>>::Error: Debug,

fn bits<const START: usize, const END: usize>(&self) -> UnwrapBitsExample

impl Bits<UnwrapBitsExample> for i16

where UnwrapBitsExample: TryFrom<i16> + Into<i16>, <UnwrapBitsExample as TryFrom<i16>>::Error: Debug,

fn bits<const START: usize, const END: usize>(&self) -> UnwrapBitsExample

impl Bits<UnwrapBitsExample> for i32

where UnwrapBitsExample: TryFrom<i32> + Into<i32>, <UnwrapBitsExample as TryFrom<i32>>::Error: Debug,

fn bits<const START: usize, const END: usize>(&self) -> UnwrapBitsExample

impl Bits<UnwrapBitsExample> for i64

where UnwrapBitsExample: TryFrom<i64> + Into<i64>, <UnwrapBitsExample as TryFrom<i64>>::Error: Debug,

fn bits<const START: usize, const END: usize>(&self) -> UnwrapBitsExample

impl Bits<UnwrapBitsExample> for i128

where UnwrapBitsExample: TryFrom<i128> + Into<i128>, <UnwrapBitsExample as TryFrom<i128>>::Error: Debug,

fn bits<const START: usize, const END: usize>(&self) -> UnwrapBitsExample

impl Bits<UnwrapBitsExample> for u8

where UnwrapBitsExample: TryFrom<u8> + Into<u8>, <UnwrapBitsExample as TryFrom<u8>>::Error: Debug,

fn bits<const START: usize, const END: usize>(&self) -> UnwrapBitsExample

impl Bits<UnwrapBitsExample> for u16

where UnwrapBitsExample: TryFrom<u16> + Into<u16>, <UnwrapBitsExample as TryFrom<u16>>::Error: Debug,

fn bits<const START: usize, const END: usize>(&self) -> UnwrapBitsExample

impl Bits<UnwrapBitsExample> for u32

where UnwrapBitsExample: TryFrom<u32> + Into<u32>, <UnwrapBitsExample as TryFrom<u32>>::Error: Debug,

fn bits<const START: usize, const END: usize>(&self) -> UnwrapBitsExample

impl Bits<UnwrapBitsExample> for u64

where UnwrapBitsExample: TryFrom<u64> + Into<u64>, <UnwrapBitsExample as TryFrom<u64>>::Error: Debug,

fn bits<const START: usize, const END: usize>(&self) -> UnwrapBitsExample

impl Bits<UnwrapBitsExample> for u128

where UnwrapBitsExample: TryFrom<u128> + Into<u128>, <UnwrapBitsExample as TryFrom<u128>>::Error: Debug,

fn bits<const START: usize, const END: usize>(&self) -> UnwrapBitsExample

impl<const M: usize> Bits<[i8; M]> for i8

fn bits<const START: usize, const END: usize>(&self) -> [i8; M]

impl<const M: usize> Bits<[i8; M]> for i16

fn bits<const START: usize, const END: usize>(&self) -> [i8; M]

impl<const M: usize> Bits<[i8; M]> for i32

fn bits<const START: usize, const END: usize>(&self) -> [i8; M]

impl<const M: usize> Bits<[i8; M]> for i64

fn bits<const START: usize, const END: usize>(&self) -> [i8; M]

impl<const M: usize> Bits<[i8; M]> for i128

fn bits<const START: usize, const END: usize>(&self) -> [i8; M]

impl<const M: usize> Bits<[i8; M]> for isize

fn bits<const START: usize, const END: usize>(&self) -> [i8; M]

impl<const M: usize> Bits<[i8; M]> for u8

fn bits<const START: usize, const END: usize>(&self) -> [i8; M]

impl<const M: usize> Bits<[i8; M]> for u16

fn bits<const START: usize, const END: usize>(&self) -> [i8; M]

impl<const M: usize> Bits<[i8; M]> for u32

fn bits<const START: usize, const END: usize>(&self) -> [i8; M]

impl<const M: usize> Bits<[i8; M]> for u64

fn bits<const START: usize, const END: usize>(&self) -> [i8; M]

impl<const M: usize> Bits<[i8; M]> for u128

fn bits<const START: usize, const END: usize>(&self) -> [i8; M]

impl<const M: usize> Bits<[i8; M]> for usize

fn bits<const START: usize, const END: usize>(&self) -> [i8; M]

impl<const M: usize> Bits<[i8; M]> for [i8]

fn bits<const START: usize, const END: usize>(&self) -> [i8; M]

impl<const M: usize> Bits<[i8; M]> for [i16]

fn bits<const START: usize, const END: usize>(&self) -> [i8; M]

impl<const M: usize> Bits<[i8; M]> for [i32]

fn bits<const START: usize, const END: usize>(&self) -> [i8; M]

impl<const M: usize> Bits<[i8; M]> for [i64]

fn bits<const START: usize, const END: usize>(&self) -> [i8; M]

impl<const M: usize> Bits<[i8; M]> for [i128]

fn bits<const START: usize, const END: usize>(&self) -> [i8; M]

impl<const M: usize> Bits<[i8; M]> for [isize]

fn bits<const START: usize, const END: usize>(&self) -> [i8; M]

impl<const M: usize> Bits<[i8; M]> for [u8]

fn bits<const START: usize, const END: usize>(&self) -> [i8; M]

impl<const M: usize> Bits<[i8; M]> for [u16]

fn bits<const START: usize, const END: usize>(&self) -> [i8; M]

impl<const M: usize> Bits<[i8; M]> for [u32]

fn bits<const START: usize, const END: usize>(&self) -> [i8; M]

impl<const M: usize> Bits<[i8; M]> for [u64]

fn bits<const START: usize, const END: usize>(&self) -> [i8; M]

impl<const M: usize> Bits<[i8; M]> for [u128]

fn bits<const START: usize, const END: usize>(&self) -> [i8; M]

impl<const M: usize> Bits<[i8; M]> for [usize]

fn bits<const START: usize, const END: usize>(&self) -> [i8; M]

impl<const M: usize> Bits<[i16; M]> for i8

fn bits<const START: usize, const END: usize>(&self) -> [i16; M]

impl<const M: usize> Bits<[i16; M]> for i16

fn bits<const START: usize, const END: usize>(&self) -> [i16; M]

impl<const M: usize> Bits<[i16; M]> for i32

fn bits<const START: usize, const END: usize>(&self) -> [i16; M]

impl<const M: usize> Bits<[i16; M]> for i64

fn bits<const START: usize, const END: usize>(&self) -> [i16; M]

impl<const M: usize> Bits<[i16; M]> for i128

fn bits<const START: usize, const END: usize>(&self) -> [i16; M]

impl<const M: usize> Bits<[i16; M]> for isize

fn bits<const START: usize, const END: usize>(&self) -> [i16; M]

impl<const M: usize> Bits<[i16; M]> for u8

fn bits<const START: usize, const END: usize>(&self) -> [i16; M]

impl<const M: usize> Bits<[i16; M]> for u16

fn bits<const START: usize, const END: usize>(&self) -> [i16; M]

impl<const M: usize> Bits<[i16; M]> for u32

fn bits<const START: usize, const END: usize>(&self) -> [i16; M]

impl<const M: usize> Bits<[i16; M]> for u64

fn bits<const START: usize, const END: usize>(&self) -> [i16; M]

impl<const M: usize> Bits<[i16; M]> for u128

fn bits<const START: usize, const END: usize>(&self) -> [i16; M]

impl<const M: usize> Bits<[i16; M]> for usize

fn bits<const START: usize, const END: usize>(&self) -> [i16; M]

impl<const M: usize> Bits<[i16; M]> for [i8]

fn bits<const START: usize, const END: usize>(&self) -> [i16; M]

impl<const M: usize> Bits<[i16; M]> for [i16]

fn bits<const START: usize, const END: usize>(&self) -> [i16; M]

impl<const M: usize> Bits<[i16; M]> for [i32]

fn bits<const START: usize, const END: usize>(&self) -> [i16; M]

impl<const M: usize> Bits<[i16; M]> for [i64]

fn bits<const START: usize, const END: usize>(&self) -> [i16; M]

impl<const M: usize> Bits<[i16; M]> for [i128]

fn bits<const START: usize, const END: usize>(&self) -> [i16; M]

impl<const M: usize> Bits<[i16; M]> for [isize]

fn bits<const START: usize, const END: usize>(&self) -> [i16; M]

impl<const M: usize> Bits<[i16; M]> for [u8]

fn bits<const START: usize, const END: usize>(&self) -> [i16; M]

impl<const M: usize> Bits<[i16; M]> for [u16]

fn bits<const START: usize, const END: usize>(&self) -> [i16; M]

impl<const M: usize> Bits<[i16; M]> for [u32]

fn bits<const START: usize, const END: usize>(&self) -> [i16; M]

impl<const M: usize> Bits<[i16; M]> for [u64]

fn bits<const START: usize, const END: usize>(&self) -> [i16; M]

impl<const M: usize> Bits<[i16; M]> for [u128]

fn bits<const START: usize, const END: usize>(&self) -> [i16; M]

impl<const M: usize> Bits<[i16; M]> for [usize]

fn bits<const START: usize, const END: usize>(&self) -> [i16; M]

impl<const M: usize> Bits<[i32; M]> for i8

fn bits<const START: usize, const END: usize>(&self) -> [i32; M]

impl<const M: usize> Bits<[i32; M]> for i16

fn bits<const START: usize, const END: usize>(&self) -> [i32; M]

impl<const M: usize> Bits<[i32; M]> for i32

fn bits<const START: usize, const END: usize>(&self) -> [i32; M]

impl<const M: usize> Bits<[i32; M]> for i64

fn bits<const START: usize, const END: usize>(&self) -> [i32; M]

impl<const M: usize> Bits<[i32; M]> for i128

fn bits<const START: usize, const END: usize>(&self) -> [i32; M]

impl<const M: usize> Bits<[i32; M]> for isize

fn bits<const START: usize, const END: usize>(&self) -> [i32; M]

impl<const M: usize> Bits<[i32; M]> for u8

fn bits<const START: usize, const END: usize>(&self) -> [i32; M]

impl<const M: usize> Bits<[i32; M]> for u16

fn bits<const START: usize, const END: usize>(&self) -> [i32; M]

impl<const M: usize> Bits<[i32; M]> for u32

fn bits<const START: usize, const END: usize>(&self) -> [i32; M]

impl<const M: usize> Bits<[i32; M]> for u64

fn bits<const START: usize, const END: usize>(&self) -> [i32; M]

impl<const M: usize> Bits<[i32; M]> for u128

fn bits<const START: usize, const END: usize>(&self) -> [i32; M]

impl<const M: usize> Bits<[i32; M]> for usize

fn bits<const START: usize, const END: usize>(&self) -> [i32; M]

impl<const M: usize> Bits<[i32; M]> for [i8]

fn bits<const START: usize, const END: usize>(&self) -> [i32; M]

impl<const M: usize> Bits<[i32; M]> for [i16]

fn bits<const START: usize, const END: usize>(&self) -> [i32; M]

impl<const M: usize> Bits<[i32; M]> for [i32]

fn bits<const START: usize, const END: usize>(&self) -> [i32; M]

impl<const M: usize> Bits<[i32; M]> for [i64]

fn bits<const START: usize, const END: usize>(&self) -> [i32; M]

impl<const M: usize> Bits<[i32; M]> for [i128]

fn bits<const START: usize, const END: usize>(&self) -> [i32; M]

impl<const M: usize> Bits<[i32; M]> for [isize]

fn bits<const START: usize, const END: usize>(&self) -> [i32; M]

impl<const M: usize> Bits<[i32; M]> for [u8]

fn bits<const START: usize, const END: usize>(&self) -> [i32; M]

impl<const M: usize> Bits<[i32; M]> for [u16]

fn bits<const START: usize, const END: usize>(&self) -> [i32; M]

impl<const M: usize> Bits<[i32; M]> for [u32]

fn bits<const START: usize, const END: usize>(&self) -> [i32; M]

impl<const M: usize> Bits<[i32; M]> for [u64]

fn bits<const START: usize, const END: usize>(&self) -> [i32; M]

impl<const M: usize> Bits<[i32; M]> for [u128]

fn bits<const START: usize, const END: usize>(&self) -> [i32; M]

impl<const M: usize> Bits<[i32; M]> for [usize]

fn bits<const START: usize, const END: usize>(&self) -> [i32; M]

impl<const M: usize> Bits<[i64; M]> for i8

fn bits<const START: usize, const END: usize>(&self) -> [i64; M]

impl<const M: usize> Bits<[i64; M]> for i16

fn bits<const START: usize, const END: usize>(&self) -> [i64; M]

impl<const M: usize> Bits<[i64; M]> for i32

fn bits<const START: usize, const END: usize>(&self) -> [i64; M]

impl<const M: usize> Bits<[i64; M]> for i64

fn bits<const START: usize, const END: usize>(&self) -> [i64; M]

impl<const M: usize> Bits<[i64; M]> for i128

fn bits<const START: usize, const END: usize>(&self) -> [i64; M]

impl<const M: usize> Bits<[i64; M]> for isize

fn bits<const START: usize, const END: usize>(&self) -> [i64; M]

impl<const M: usize> Bits<[i64; M]> for u8

fn bits<const START: usize, const END: usize>(&self) -> [i64; M]

impl<const M: usize> Bits<[i64; M]> for u16

fn bits<const START: usize, const END: usize>(&self) -> [i64; M]

impl<const M: usize> Bits<[i64; M]> for u32

fn bits<const START: usize, const END: usize>(&self) -> [i64; M]

impl<const M: usize> Bits<[i64; M]> for u64

fn bits<const START: usize, const END: usize>(&self) -> [i64; M]

impl<const M: usize> Bits<[i64; M]> for u128

fn bits<const START: usize, const END: usize>(&self) -> [i64; M]

impl<const M: usize> Bits<[i64; M]> for usize

fn bits<const START: usize, const END: usize>(&self) -> [i64; M]

impl<const M: usize> Bits<[i64; M]> for [i8]

fn bits<const START: usize, const END: usize>(&self) -> [i64; M]

impl<const M: usize> Bits<[i64; M]> for [i16]

fn bits<const START: usize, const END: usize>(&self) -> [i64; M]

impl<const M: usize> Bits<[i64; M]> for [i32]

fn bits<const START: usize, const END: usize>(&self) -> [i64; M]

impl<const M: usize> Bits<[i64; M]> for [i64]

fn bits<const START: usize, const END: usize>(&self) -> [i64; M]

impl<const M: usize> Bits<[i64; M]> for [i128]

fn bits<const START: usize, const END: usize>(&self) -> [i64; M]

impl<const M: usize> Bits<[i64; M]> for [isize]

fn bits<const START: usize, const END: usize>(&self) -> [i64; M]

impl<const M: usize> Bits<[i64; M]> for [u8]

fn bits<const START: usize, const END: usize>(&self) -> [i64; M]

impl<const M: usize> Bits<[i64; M]> for [u16]

fn bits<const START: usize, const END: usize>(&self) -> [i64; M]

impl<const M: usize> Bits<[i64; M]> for [u32]

fn bits<const START: usize, const END: usize>(&self) -> [i64; M]

impl<const M: usize> Bits<[i64; M]> for [u64]

fn bits<const START: usize, const END: usize>(&self) -> [i64; M]

impl<const M: usize> Bits<[i64; M]> for [u128]

fn bits<const START: usize, const END: usize>(&self) -> [i64; M]

impl<const M: usize> Bits<[i64; M]> for [usize]

fn bits<const START: usize, const END: usize>(&self) -> [i64; M]

impl<const M: usize> Bits<[i128; M]> for i8

fn bits<const START: usize, const END: usize>(&self) -> [i128; M]

impl<const M: usize> Bits<[i128; M]> for i16

fn bits<const START: usize, const END: usize>(&self) -> [i128; M]

impl<const M: usize> Bits<[i128; M]> for i32

fn bits<const START: usize, const END: usize>(&self) -> [i128; M]

impl<const M: usize> Bits<[i128; M]> for i64

fn bits<const START: usize, const END: usize>(&self) -> [i128; M]

impl<const M: usize> Bits<[i128; M]> for i128

fn bits<const START: usize, const END: usize>(&self) -> [i128; M]

impl<const M: usize> Bits<[i128; M]> for isize

fn bits<const START: usize, const END: usize>(&self) -> [i128; M]

impl<const M: usize> Bits<[i128; M]> for u8

fn bits<const START: usize, const END: usize>(&self) -> [i128; M]

impl<const M: usize> Bits<[i128; M]> for u16

fn bits<const START: usize, const END: usize>(&self) -> [i128; M]

impl<const M: usize> Bits<[i128; M]> for u32

fn bits<const START: usize, const END: usize>(&self) -> [i128; M]

impl<const M: usize> Bits<[i128; M]> for u64

fn bits<const START: usize, const END: usize>(&self) -> [i128; M]

impl<const M: usize> Bits<[i128; M]> for u128

fn bits<const START: usize, const END: usize>(&self) -> [i128; M]

impl<const M: usize> Bits<[i128; M]> for usize

fn bits<const START: usize, const END: usize>(&self) -> [i128; M]

impl<const M: usize> Bits<[i128; M]> for [i8]

fn bits<const START: usize, const END: usize>(&self) -> [i128; M]

impl<const M: usize> Bits<[i128; M]> for [i16]

fn bits<const START: usize, const END: usize>(&self) -> [i128; M]

impl<const M: usize> Bits<[i128; M]> for [i32]

fn bits<const START: usize, const END: usize>(&self) -> [i128; M]

impl<const M: usize> Bits<[i128; M]> for [i64]

fn bits<const START: usize, const END: usize>(&self) -> [i128; M]

impl<const M: usize> Bits<[i128; M]> for [i128]

fn bits<const START: usize, const END: usize>(&self) -> [i128; M]

impl<const M: usize> Bits<[i128; M]> for [isize]

fn bits<const START: usize, const END: usize>(&self) -> [i128; M]

impl<const M: usize> Bits<[i128; M]> for [u8]

fn bits<const START: usize, const END: usize>(&self) -> [i128; M]

impl<const M: usize> Bits<[i128; M]> for [u16]

fn bits<const START: usize, const END: usize>(&self) -> [i128; M]

impl<const M: usize> Bits<[i128; M]> for [u32]

fn bits<const START: usize, const END: usize>(&self) -> [i128; M]

impl<const M: usize> Bits<[i128; M]> for [u64]

fn bits<const START: usize, const END: usize>(&self) -> [i128; M]

impl<const M: usize> Bits<[i128; M]> for [u128]

fn bits<const START: usize, const END: usize>(&self) -> [i128; M]

impl<const M: usize> Bits<[i128; M]> for [usize]

fn bits<const START: usize, const END: usize>(&self) -> [i128; M]

impl<const M: usize> Bits<[isize; M]> for i8

fn bits<const START: usize, const END: usize>(&self) -> [isize; M]

impl<const M: usize> Bits<[isize; M]> for i16

fn bits<const START: usize, const END: usize>(&self) -> [isize; M]

impl<const M: usize> Bits<[isize; M]> for i32

fn bits<const START: usize, const END: usize>(&self) -> [isize; M]

impl<const M: usize> Bits<[isize; M]> for i64

fn bits<const START: usize, const END: usize>(&self) -> [isize; M]

impl<const M: usize> Bits<[isize; M]> for i128

fn bits<const START: usize, const END: usize>(&self) -> [isize; M]

impl<const M: usize> Bits<[isize; M]> for isize

fn bits<const START: usize, const END: usize>(&self) -> [isize; M]

impl<const M: usize> Bits<[isize; M]> for u8

fn bits<const START: usize, const END: usize>(&self) -> [isize; M]

impl<const M: usize> Bits<[isize; M]> for u16

fn bits<const START: usize, const END: usize>(&self) -> [isize; M]

impl<const M: usize> Bits<[isize; M]> for u32

fn bits<const START: usize, const END: usize>(&self) -> [isize; M]

impl<const M: usize> Bits<[isize; M]> for u64

fn bits<const START: usize, const END: usize>(&self) -> [isize; M]

impl<const M: usize> Bits<[isize; M]> for u128

fn bits<const START: usize, const END: usize>(&self) -> [isize; M]

impl<const M: usize> Bits<[isize; M]> for usize

fn bits<const START: usize, const END: usize>(&self) -> [isize; M]

impl<const M: usize> Bits<[isize; M]> for [i8]

fn bits<const START: usize, const END: usize>(&self) -> [isize; M]

impl<const M: usize> Bits<[isize; M]> for [i16]

fn bits<const START: usize, const END: usize>(&self) -> [isize; M]

impl<const M: usize> Bits<[isize; M]> for [i32]

fn bits<const START: usize, const END: usize>(&self) -> [isize; M]

impl<const M: usize> Bits<[isize; M]> for [i64]

fn bits<const START: usize, const END: usize>(&self) -> [isize; M]

impl<const M: usize> Bits<[isize; M]> for [i128]

fn bits<const START: usize, const END: usize>(&self) -> [isize; M]

impl<const M: usize> Bits<[isize; M]> for [isize]

fn bits<const START: usize, const END: usize>(&self) -> [isize; M]

impl<const M: usize> Bits<[isize; M]> for [u8]

fn bits<const START: usize, const END: usize>(&self) -> [isize; M]

impl<const M: usize> Bits<[isize; M]> for [u16]

fn bits<const START: usize, const END: usize>(&self) -> [isize; M]

impl<const M: usize> Bits<[isize; M]> for [u32]

fn bits<const START: usize, const END: usize>(&self) -> [isize; M]

impl<const M: usize> Bits<[isize; M]> for [u64]

fn bits<const START: usize, const END: usize>(&self) -> [isize; M]

impl<const M: usize> Bits<[isize; M]> for [u128]

fn bits<const START: usize, const END: usize>(&self) -> [isize; M]

impl<const M: usize> Bits<[isize; M]> for [usize]

fn bits<const START: usize, const END: usize>(&self) -> [isize; M]

impl<const M: usize> Bits<[u8; M]> for i8

fn bits<const START: usize, const END: usize>(&self) -> [u8; M]

impl<const M: usize> Bits<[u8; M]> for i16

fn bits<const START: usize, const END: usize>(&self) -> [u8; M]

impl<const M: usize> Bits<[u8; M]> for i32

fn bits<const START: usize, const END: usize>(&self) -> [u8; M]

impl<const M: usize> Bits<[u8; M]> for i64

fn bits<const START: usize, const END: usize>(&self) -> [u8; M]

impl<const M: usize> Bits<[u8; M]> for i128

fn bits<const START: usize, const END: usize>(&self) -> [u8; M]

impl<const M: usize> Bits<[u8; M]> for isize

fn bits<const START: usize, const END: usize>(&self) -> [u8; M]

impl<const M: usize> Bits<[u8; M]> for u8

fn bits<const START: usize, const END: usize>(&self) -> [u8; M]

impl<const M: usize> Bits<[u8; M]> for u16

fn bits<const START: usize, const END: usize>(&self) -> [u8; M]

impl<const M: usize> Bits<[u8; M]> for u32

fn bits<const START: usize, const END: usize>(&self) -> [u8; M]

impl<const M: usize> Bits<[u8; M]> for u64

fn bits<const START: usize, const END: usize>(&self) -> [u8; M]

impl<const M: usize> Bits<[u8; M]> for u128

fn bits<const START: usize, const END: usize>(&self) -> [u8; M]

impl<const M: usize> Bits<[u8; M]> for usize

fn bits<const START: usize, const END: usize>(&self) -> [u8; M]

impl<const M: usize> Bits<[u8; M]> for [i8]

fn bits<const START: usize, const END: usize>(&self) -> [u8; M]

impl<const M: usize> Bits<[u8; M]> for [i16]

fn bits<const START: usize, const END: usize>(&self) -> [u8; M]

impl<const M: usize> Bits<[u8; M]> for [i32]

fn bits<const START: usize, const END: usize>(&self) -> [u8; M]

impl<const M: usize> Bits<[u8; M]> for [i64]

fn bits<const START: usize, const END: usize>(&self) -> [u8; M]

impl<const M: usize> Bits<[u8; M]> for [i128]

fn bits<const START: usize, const END: usize>(&self) -> [u8; M]

impl<const M: usize> Bits<[u8; M]> for [isize]

fn bits<const START: usize, const END: usize>(&self) -> [u8; M]

impl<const M: usize> Bits<[u8; M]> for [u8]

fn bits<const START: usize, const END: usize>(&self) -> [u8; M]

impl<const M: usize> Bits<[u8; M]> for [u16]

fn bits<const START: usize, const END: usize>(&self) -> [u8; M]

impl<const M: usize> Bits<[u8; M]> for [u32]

fn bits<const START: usize, const END: usize>(&self) -> [u8; M]

impl<const M: usize> Bits<[u8; M]> for [u64]

fn bits<const START: usize, const END: usize>(&self) -> [u8; M]

impl<const M: usize> Bits<[u8; M]> for [u128]

fn bits<const START: usize, const END: usize>(&self) -> [u8; M]

impl<const M: usize> Bits<[u8; M]> for [usize]

fn bits<const START: usize, const END: usize>(&self) -> [u8; M]

impl<const M: usize> Bits<[u16; M]> for i8

fn bits<const START: usize, const END: usize>(&self) -> [u16; M]

impl<const M: usize> Bits<[u16; M]> for i16

fn bits<const START: usize, const END: usize>(&self) -> [u16; M]

impl<const M: usize> Bits<[u16; M]> for i32

fn bits<const START: usize, const END: usize>(&self) -> [u16; M]

impl<const M: usize> Bits<[u16; M]> for i64

fn bits<const START: usize, const END: usize>(&self) -> [u16; M]

impl<const M: usize> Bits<[u16; M]> for i128

fn bits<const START: usize, const END: usize>(&self) -> [u16; M]

impl<const M: usize> Bits<[u16; M]> for isize

fn bits<const START: usize, const END: usize>(&self) -> [u16; M]

impl<const M: usize> Bits<[u16; M]> for u8

fn bits<const START: usize, const END: usize>(&self) -> [u16; M]

impl<const M: usize> Bits<[u16; M]> for u16

fn bits<const START: usize, const END: usize>(&self) -> [u16; M]

impl<const M: usize> Bits<[u16; M]> for u32

fn bits<const START: usize, const END: usize>(&self) -> [u16; M]

impl<const M: usize> Bits<[u16; M]> for u64

fn bits<const START: usize, const END: usize>(&self) -> [u16; M]

impl<const M: usize> Bits<[u16; M]> for u128

fn bits<const START: usize, const END: usize>(&self) -> [u16; M]

impl<const M: usize> Bits<[u16; M]> for usize

fn bits<const START: usize, const END: usize>(&self) -> [u16; M]

impl<const M: usize> Bits<[u16; M]> for [i8]

fn bits<const START: usize, const END: usize>(&self) -> [u16; M]

impl<const M: usize> Bits<[u16; M]> for [i16]

fn bits<const START: usize, const END: usize>(&self) -> [u16; M]

impl<const M: usize> Bits<[u16; M]> for [i32]

fn bits<const START: usize, const END: usize>(&self) -> [u16; M]

impl<const M: usize> Bits<[u16; M]> for [i64]

fn bits<const START: usize, const END: usize>(&self) -> [u16; M]

impl<const M: usize> Bits<[u16; M]> for [i128]

fn bits<const START: usize, const END: usize>(&self) -> [u16; M]

impl<const M: usize> Bits<[u16; M]> for [isize]

fn bits<const START: usize, const END: usize>(&self) -> [u16; M]

impl<const M: usize> Bits<[u16; M]> for [u8]

fn bits<const START: usize, const END: usize>(&self) -> [u16; M]

impl<const M: usize> Bits<[u16; M]> for [u16]

fn bits<const START: usize, const END: usize>(&self) -> [u16; M]

impl<const M: usize> Bits<[u16; M]> for [u32]

fn bits<const START: usize, const END: usize>(&self) -> [u16; M]

impl<const M: usize> Bits<[u16; M]> for [u64]

fn bits<const START: usize, const END: usize>(&self) -> [u16; M]

impl<const M: usize> Bits<[u16; M]> for [u128]

fn bits<const START: usize, const END: usize>(&self) -> [u16; M]

impl<const M: usize> Bits<[u16; M]> for [usize]

fn bits<const START: usize, const END: usize>(&self) -> [u16; M]

impl<const M: usize> Bits<[u32; M]> for i8

fn bits<const START: usize, const END: usize>(&self) -> [u32; M]

impl<const M: usize> Bits<[u32; M]> for i16

fn bits<const START: usize, const END: usize>(&self) -> [u32; M]

impl<const M: usize> Bits<[u32; M]> for i32

fn bits<const START: usize, const END: usize>(&self) -> [u32; M]

impl<const M: usize> Bits<[u32; M]> for i64

fn bits<const START: usize, const END: usize>(&self) -> [u32; M]

impl<const M: usize> Bits<[u32; M]> for i128

fn bits<const START: usize, const END: usize>(&self) -> [u32; M]

impl<const M: usize> Bits<[u32; M]> for isize

fn bits<const START: usize, const END: usize>(&self) -> [u32; M]

impl<const M: usize> Bits<[u32; M]> for u8

fn bits<const START: usize, const END: usize>(&self) -> [u32; M]

impl<const M: usize> Bits<[u32; M]> for u16

fn bits<const START: usize, const END: usize>(&self) -> [u32; M]

impl<const M: usize> Bits<[u32; M]> for u32

fn bits<const START: usize, const END: usize>(&self) -> [u32; M]

impl<const M: usize> Bits<[u32; M]> for u64

fn bits<const START: usize, const END: usize>(&self) -> [u32; M]

impl<const M: usize> Bits<[u32; M]> for u128

fn bits<const START: usize, const END: usize>(&self) -> [u32; M]

impl<const M: usize> Bits<[u32; M]> for usize

fn bits<const START: usize, const END: usize>(&self) -> [u32; M]

impl<const M: usize> Bits<[u32; M]> for [i8]

fn bits<const START: usize, const END: usize>(&self) -> [u32; M]

impl<const M: usize> Bits<[u32; M]> for [i16]

fn bits<const START: usize, const END: usize>(&self) -> [u32; M]

impl<const M: usize> Bits<[u32; M]> for [i32]

fn bits<const START: usize, const END: usize>(&self) -> [u32; M]

impl<const M: usize> Bits<[u32; M]> for [i64]

fn bits<const START: usize, const END: usize>(&self) -> [u32; M]

impl<const M: usize> Bits<[u32; M]> for [i128]

fn bits<const START: usize, const END: usize>(&self) -> [u32; M]

impl<const M: usize> Bits<[u32; M]> for [isize]

fn bits<const START: usize, const END: usize>(&self) -> [u32; M]

impl<const M: usize> Bits<[u32; M]> for [u8]

fn bits<const START: usize, const END: usize>(&self) -> [u32; M]

impl<const M: usize> Bits<[u32; M]> for [u16]

fn bits<const START: usize, const END: usize>(&self) -> [u32; M]

impl<const M: usize> Bits<[u32; M]> for [u32]

fn bits<const START: usize, const END: usize>(&self) -> [u32; M]

impl<const M: usize> Bits<[u32; M]> for [u64]

fn bits<const START: usize, const END: usize>(&self) -> [u32; M]

impl<const M: usize> Bits<[u32; M]> for [u128]

fn bits<const START: usize, const END: usize>(&self) -> [u32; M]

impl<const M: usize> Bits<[u32; M]> for [usize]

fn bits<const START: usize, const END: usize>(&self) -> [u32; M]

impl<const M: usize> Bits<[u64; M]> for i8

fn bits<const START: usize, const END: usize>(&self) -> [u64; M]

impl<const M: usize> Bits<[u64; M]> for i16

fn bits<const START: usize, const END: usize>(&self) -> [u64; M]

impl<const M: usize> Bits<[u64; M]> for i32

fn bits<const START: usize, const END: usize>(&self) -> [u64; M]

impl<const M: usize> Bits<[u64; M]> for i64

fn bits<const START: usize, const END: usize>(&self) -> [u64; M]

impl<const M: usize> Bits<[u64; M]> for i128

fn bits<const START: usize, const END: usize>(&self) -> [u64; M]

impl<const M: usize> Bits<[u64; M]> for isize

fn bits<const START: usize, const END: usize>(&self) -> [u64; M]

impl<const M: usize> Bits<[u64; M]> for u8

fn bits<const START: usize, const END: usize>(&self) -> [u64; M]

impl<const M: usize> Bits<[u64; M]> for u16

fn bits<const START: usize, const END: usize>(&self) -> [u64; M]

impl<const M: usize> Bits<[u64; M]> for u32

fn bits<const START: usize, const END: usize>(&self) -> [u64; M]

impl<const M: usize> Bits<[u64; M]> for u64

fn bits<const START: usize, const END: usize>(&self) -> [u64; M]

impl<const M: usize> Bits<[u64; M]> for u128

fn bits<const START: usize, const END: usize>(&self) -> [u64; M]

impl<const M: usize> Bits<[u64; M]> for usize

fn bits<const START: usize, const END: usize>(&self) -> [u64; M]

impl<const M: usize> Bits<[u64; M]> for [i8]

fn bits<const START: usize, const END: usize>(&self) -> [u64; M]

impl<const M: usize> Bits<[u64; M]> for [i16]

fn bits<const START: usize, const END: usize>(&self) -> [u64; M]

impl<const M: usize> Bits<[u64; M]> for [i32]

fn bits<const START: usize, const END: usize>(&self) -> [u64; M]

impl<const M: usize> Bits<[u64; M]> for [i64]

fn bits<const START: usize, const END: usize>(&self) -> [u64; M]

impl<const M: usize> Bits<[u64; M]> for [i128]

fn bits<const START: usize, const END: usize>(&self) -> [u64; M]

impl<const M: usize> Bits<[u64; M]> for [isize]

fn bits<const START: usize, const END: usize>(&self) -> [u64; M]

impl<const M: usize> Bits<[u64; M]> for [u8]

fn bits<const START: usize, const END: usize>(&self) -> [u64; M]

impl<const M: usize> Bits<[u64; M]> for [u16]

fn bits<const START: usize, const END: usize>(&self) -> [u64; M]

impl<const M: usize> Bits<[u64; M]> for [u32]

fn bits<const START: usize, const END: usize>(&self) -> [u64; M]

impl<const M: usize> Bits<[u64; M]> for [u64]

fn bits<const START: usize, const END: usize>(&self) -> [u64; M]

impl<const M: usize> Bits<[u64; M]> for [u128]

fn bits<const START: usize, const END: usize>(&self) -> [u64; M]

impl<const M: usize> Bits<[u64; M]> for [usize]

fn bits<const START: usize, const END: usize>(&self) -> [u64; M]

impl<const M: usize> Bits<[u128; M]> for i8

fn bits<const START: usize, const END: usize>(&self) -> [u128; M]

impl<const M: usize> Bits<[u128; M]> for i16

fn bits<const START: usize, const END: usize>(&self) -> [u128; M]

impl<const M: usize> Bits<[u128; M]> for i32

fn bits<const START: usize, const END: usize>(&self) -> [u128; M]

impl<const M: usize> Bits<[u128; M]> for i64

fn bits<const START: usize, const END: usize>(&self) -> [u128; M]

impl<const M: usize> Bits<[u128; M]> for i128

fn bits<const START: usize, const END: usize>(&self) -> [u128; M]

impl<const M: usize> Bits<[u128; M]> for isize

fn bits<const START: usize, const END: usize>(&self) -> [u128; M]

impl<const M: usize> Bits<[u128; M]> for u8

fn bits<const START: usize, const END: usize>(&self) -> [u128; M]

impl<const M: usize> Bits<[u128; M]> for u16

fn bits<const START: usize, const END: usize>(&self) -> [u128; M]

impl<const M: usize> Bits<[u128; M]> for u32

fn bits<const START: usize, const END: usize>(&self) -> [u128; M]

impl<const M: usize> Bits<[u128; M]> for u64

fn bits<const START: usize, const END: usize>(&self) -> [u128; M]

impl<const M: usize> Bits<[u128; M]> for u128

fn bits<const START: usize, const END: usize>(&self) -> [u128; M]

impl<const M: usize> Bits<[u128; M]> for usize

fn bits<const START: usize, const END: usize>(&self) -> [u128; M]

impl<const M: usize> Bits<[u128; M]> for [i8]

fn bits<const START: usize, const END: usize>(&self) -> [u128; M]

impl<const M: usize> Bits<[u128; M]> for [i16]

fn bits<const START: usize, const END: usize>(&self) -> [u128; M]

impl<const M: usize> Bits<[u128; M]> for [i32]

fn bits<const START: usize, const END: usize>(&self) -> [u128; M]

impl<const M: usize> Bits<[u128; M]> for [i64]

fn bits<const START: usize, const END: usize>(&self) -> [u128; M]

impl<const M: usize> Bits<[u128; M]> for [i128]

fn bits<const START: usize, const END: usize>(&self) -> [u128; M]

impl<const M: usize> Bits<[u128; M]> for [isize]

fn bits<const START: usize, const END: usize>(&self) -> [u128; M]

impl<const M: usize> Bits<[u128; M]> for [u8]

fn bits<const START: usize, const END: usize>(&self) -> [u128; M]

impl<const M: usize> Bits<[u128; M]> for [u16]

fn bits<const START: usize, const END: usize>(&self) -> [u128; M]

impl<const M: usize> Bits<[u128; M]> for [u32]

fn bits<const START: usize, const END: usize>(&self) -> [u128; M]

impl<const M: usize> Bits<[u128; M]> for [u64]

fn bits<const START: usize, const END: usize>(&self) -> [u128; M]

impl<const M: usize> Bits<[u128; M]> for [u128]

fn bits<const START: usize, const END: usize>(&self) -> [u128; M]

impl<const M: usize> Bits<[u128; M]> for [usize]

fn bits<const START: usize, const END: usize>(&self) -> [u128; M]

impl<const M: usize> Bits<[usize; M]> for i8

fn bits<const START: usize, const END: usize>(&self) -> [usize; M]

impl<const M: usize> Bits<[usize; M]> for i16

fn bits<const START: usize, const END: usize>(&self) -> [usize; M]

impl<const M: usize> Bits<[usize; M]> for i32

fn bits<const START: usize, const END: usize>(&self) -> [usize; M]

impl<const M: usize> Bits<[usize; M]> for i64

fn bits<const START: usize, const END: usize>(&self) -> [usize; M]

impl<const M: usize> Bits<[usize; M]> for i128

fn bits<const START: usize, const END: usize>(&self) -> [usize; M]

impl<const M: usize> Bits<[usize; M]> for isize

fn bits<const START: usize, const END: usize>(&self) -> [usize; M]

impl<const M: usize> Bits<[usize; M]> for u8

fn bits<const START: usize, const END: usize>(&self) -> [usize; M]

impl<const M: usize> Bits<[usize; M]> for u16

fn bits<const START: usize, const END: usize>(&self) -> [usize; M]

impl<const M: usize> Bits<[usize; M]> for u32

fn bits<const START: usize, const END: usize>(&self) -> [usize; M]

impl<const M: usize> Bits<[usize; M]> for u64

fn bits<const START: usize, const END: usize>(&self) -> [usize; M]

impl<const M: usize> Bits<[usize; M]> for u128

fn bits<const START: usize, const END: usize>(&self) -> [usize; M]

impl<const M: usize> Bits<[usize; M]> for usize

fn bits<const START: usize, const END: usize>(&self) -> [usize; M]

impl<const M: usize> Bits<[usize; M]> for [i8]

fn bits<const START: usize, const END: usize>(&self) -> [usize; M]

impl<const M: usize> Bits<[usize; M]> for [i16]

fn bits<const START: usize, const END: usize>(&self) -> [usize; M]

impl<const M: usize> Bits<[usize; M]> for [i32]

fn bits<const START: usize, const END: usize>(&self) -> [usize; M]

impl<const M: usize> Bits<[usize; M]> for [i64]

fn bits<const START: usize, const END: usize>(&self) -> [usize; M]

impl<const M: usize> Bits<[usize; M]> for [i128]

fn bits<const START: usize, const END: usize>(&self) -> [usize; M]

impl<const M: usize> Bits<[usize; M]> for [isize]

fn bits<const START: usize, const END: usize>(&self) -> [usize; M]

impl<const M: usize> Bits<[usize; M]> for [u8]

fn bits<const START: usize, const END: usize>(&self) -> [usize; M]

impl<const M: usize> Bits<[usize; M]> for [u16]

fn bits<const START: usize, const END: usize>(&self) -> [usize; M]

impl<const M: usize> Bits<[usize; M]> for [u32]

fn bits<const START: usize, const END: usize>(&self) -> [usize; M]

impl<const M: usize> Bits<[usize; M]> for [u64]

fn bits<const START: usize, const END: usize>(&self) -> [usize; M]

impl<const M: usize> Bits<[usize; M]> for [u128]

fn bits<const START: usize, const END: usize>(&self) -> [usize; M]

impl<const M: usize> Bits<[usize; M]> for [usize]

fn bits<const START: usize, const END: usize>(&self) -> [usize; M]

impl<const M: usize, const N: usize> Bits<[i8; M]> for [i8; N]

fn bits<const START: usize, const END: usize>(&self) -> [i8; M]

impl<const M: usize, const N: usize> Bits<[i8; M]> for [i16; N]

fn bits<const START: usize, const END: usize>(&self) -> [i8; M]

impl<const M: usize, const N: usize> Bits<[i8; M]> for [i32; N]

fn bits<const START: usize, const END: usize>(&self) -> [i8; M]

impl<const M: usize, const N: usize> Bits<[i8; M]> for [i64; N]

fn bits<const START: usize, const END: usize>(&self) -> [i8; M]

impl<const M: usize, const N: usize> Bits<[i8; M]> for [i128; N]

fn bits<const START: usize, const END: usize>(&self) -> [i8; M]

impl<const M: usize, const N: usize> Bits<[i8; M]> for [isize; N]

fn bits<const START: usize, const END: usize>(&self) -> [i8; M]

impl<const M: usize, const N: usize> Bits<[i8; M]> for [u8; N]

fn bits<const START: usize, const END: usize>(&self) -> [i8; M]

impl<const M: usize, const N: usize> Bits<[i8; M]> for [u16; N]

fn bits<const START: usize, const END: usize>(&self) -> [i8; M]

impl<const M: usize, const N: usize> Bits<[i8; M]> for [u32; N]

fn bits<const START: usize, const END: usize>(&self) -> [i8; M]

impl<const M: usize, const N: usize> Bits<[i8; M]> for [u64; N]

fn bits<const START: usize, const END: usize>(&self) -> [i8; M]

impl<const M: usize, const N: usize> Bits<[i8; M]> for [u128; N]

fn bits<const START: usize, const END: usize>(&self) -> [i8; M]

impl<const M: usize, const N: usize> Bits<[i8; M]> for [usize; N]

fn bits<const START: usize, const END: usize>(&self) -> [i8; M]

impl<const M: usize, const N: usize> Bits<[i16; M]> for [i8; N]

fn bits<const START: usize, const END: usize>(&self) -> [i16; M]

impl<const M: usize, const N: usize> Bits<[i16; M]> for [i16; N]

fn bits<const START: usize, const END: usize>(&self) -> [i16; M]

impl<const M: usize, const N: usize> Bits<[i16; M]> for [i32; N]

fn bits<const START: usize, const END: usize>(&self) -> [i16; M]

impl<const M: usize, const N: usize> Bits<[i16; M]> for [i64; N]

fn bits<const START: usize, const END: usize>(&self) -> [i16; M]

impl<const M: usize, const N: usize> Bits<[i16; M]> for [i128; N]

fn bits<const START: usize, const END: usize>(&self) -> [i16; M]

impl<const M: usize, const N: usize> Bits<[i16; M]> for [isize; N]

fn bits<const START: usize, const END: usize>(&self) -> [i16; M]

impl<const M: usize, const N: usize> Bits<[i16; M]> for [u8; N]

fn bits<const START: usize, const END: usize>(&self) -> [i16; M]

impl<const M: usize, const N: usize> Bits<[i16; M]> for [u16; N]

fn bits<const START: usize, const END: usize>(&self) -> [i16; M]

impl<const M: usize, const N: usize> Bits<[i16; M]> for [u32; N]

fn bits<const START: usize, const END: usize>(&self) -> [i16; M]

impl<const M: usize, const N: usize> Bits<[i16; M]> for [u64; N]

fn bits<const START: usize, const END: usize>(&self) -> [i16; M]

impl<const M: usize, const N: usize> Bits<[i16; M]> for [u128; N]

fn bits<const START: usize, const END: usize>(&self) -> [i16; M]

impl<const M: usize, const N: usize> Bits<[i16; M]> for [usize; N]

fn bits<const START: usize, const END: usize>(&self) -> [i16; M]

impl<const M: usize, const N: usize> Bits<[i32; M]> for [i8; N]

fn bits<const START: usize, const END: usize>(&self) -> [i32; M]

impl<const M: usize, const N: usize> Bits<[i32; M]> for [i16; N]

fn bits<const START: usize, const END: usize>(&self) -> [i32; M]

impl<const M: usize, const N: usize> Bits<[i32; M]> for [i32; N]

fn bits<const START: usize, const END: usize>(&self) -> [i32; M]

impl<const M: usize, const N: usize> Bits<[i32; M]> for [i64; N]

fn bits<const START: usize, const END: usize>(&self) -> [i32; M]

impl<const M: usize, const N: usize> Bits<[i32; M]> for [i128; N]

fn bits<const START: usize, const END: usize>(&self) -> [i32; M]

impl<const M: usize, const N: usize> Bits<[i32; M]> for [isize; N]

fn bits<const START: usize, const END: usize>(&self) -> [i32; M]

impl<const M: usize, const N: usize> Bits<[i32; M]> for [u8; N]

fn bits<const START: usize, const END: usize>(&self) -> [i32; M]

impl<const M: usize, const N: usize> Bits<[i32; M]> for [u16; N]

fn bits<const START: usize, const END: usize>(&self) -> [i32; M]

impl<const M: usize, const N: usize> Bits<[i32; M]> for [u32; N]

fn bits<const START: usize, const END: usize>(&self) -> [i32; M]

impl<const M: usize, const N: usize> Bits<[i32; M]> for [u64; N]

fn bits<const START: usize, const END: usize>(&self) -> [i32; M]

impl<const M: usize, const N: usize> Bits<[i32; M]> for [u128; N]

fn bits<const START: usize, const END: usize>(&self) -> [i32; M]

impl<const M: usize, const N: usize> Bits<[i32; M]> for [usize; N]

fn bits<const START: usize, const END: usize>(&self) -> [i32; M]

impl<const M: usize, const N: usize> Bits<[i64; M]> for [i8; N]

fn bits<const START: usize, const END: usize>(&self) -> [i64; M]

impl<const M: usize, const N: usize> Bits<[i64; M]> for [i16; N]

fn bits<const START: usize, const END: usize>(&self) -> [i64; M]

impl<const M: usize, const N: usize> Bits<[i64; M]> for [i32; N]

fn bits<const START: usize, const END: usize>(&self) -> [i64; M]

impl<const M: usize, const N: usize> Bits<[i64; M]> for [i64; N]

fn bits<const START: usize, const END: usize>(&self) -> [i64; M]

impl<const M: usize, const N: usize> Bits<[i64; M]> for [i128; N]

fn bits<const START: usize, const END: usize>(&self) -> [i64; M]

impl<const M: usize, const N: usize> Bits<[i64; M]> for [isize; N]

fn bits<const START: usize, const END: usize>(&self) -> [i64; M]

impl<const M: usize, const N: usize> Bits<[i64; M]> for [u8; N]

fn bits<const START: usize, const END: usize>(&self) -> [i64; M]

impl<const M: usize, const N: usize> Bits<[i64; M]> for [u16; N]

fn bits<const START: usize, const END: usize>(&self) -> [i64; M]

impl<const M: usize, const N: usize> Bits<[i64; M]> for [u32; N]

fn bits<const START: usize, const END: usize>(&self) -> [i64; M]

impl<const M: usize, const N: usize> Bits<[i64; M]> for [u64; N]

fn bits<const START: usize, const END: usize>(&self) -> [i64; M]

impl<const M: usize, const N: usize> Bits<[i64; M]> for [u128; N]

fn bits<const START: usize, const END: usize>(&self) -> [i64; M]

impl<const M: usize, const N: usize> Bits<[i64; M]> for [usize; N]

fn bits<const START: usize, const END: usize>(&self) -> [i64; M]

impl<const M: usize, const N: usize> Bits<[i128; M]> for [i8; N]

fn bits<const START: usize, const END: usize>(&self) -> [i128; M]

impl<const M: usize, const N: usize> Bits<[i128; M]> for [i16; N]

fn bits<const START: usize, const END: usize>(&self) -> [i128; M]

impl<const M: usize, const N: usize> Bits<[i128; M]> for [i32; N]

fn bits<const START: usize, const END: usize>(&self) -> [i128; M]

impl<const M: usize, const N: usize> Bits<[i128; M]> for [i64; N]

fn bits<const START: usize, const END: usize>(&self) -> [i128; M]

impl<const M: usize, const N: usize> Bits<[i128; M]> for [i128; N]

fn bits<const START: usize, const END: usize>(&self) -> [i128; M]

impl<const M: usize, const N: usize> Bits<[i128; M]> for [isize; N]

fn bits<const START: usize, const END: usize>(&self) -> [i128; M]

impl<const M: usize, const N: usize> Bits<[i128; M]> for [u8; N]

fn bits<const START: usize, const END: usize>(&self) -> [i128; M]

impl<const M: usize, const N: usize> Bits<[i128; M]> for [u16; N]

fn bits<const START: usize, const END: usize>(&self) -> [i128; M]

impl<const M: usize, const N: usize> Bits<[i128; M]> for [u32; N]

fn bits<const START: usize, const END: usize>(&self) -> [i128; M]

impl<const M: usize, const N: usize> Bits<[i128; M]> for [u64; N]

fn bits<const START: usize, const END: usize>(&self) -> [i128; M]

impl<const M: usize, const N: usize> Bits<[i128; M]> for [u128; N]

fn bits<const START: usize, const END: usize>(&self) -> [i128; M]

impl<const M: usize, const N: usize> Bits<[i128; M]> for [usize; N]

fn bits<const START: usize, const END: usize>(&self) -> [i128; M]

impl<const M: usize, const N: usize> Bits<[isize; M]> for [i8; N]

fn bits<const START: usize, const END: usize>(&self) -> [isize; M]

impl<const M: usize, const N: usize> Bits<[isize; M]> for [i16; N]

fn bits<const START: usize, const END: usize>(&self) -> [isize; M]

impl<const M: usize, const N: usize> Bits<[isize; M]> for [i32; N]

fn bits<const START: usize, const END: usize>(&self) -> [isize; M]

impl<const M: usize, const N: usize> Bits<[isize; M]> for [i64; N]

fn bits<const START: usize, const END: usize>(&self) -> [isize; M]

impl<const M: usize, const N: usize> Bits<[isize; M]> for [i128; N]

fn bits<const START: usize, const END: usize>(&self) -> [isize; M]

impl<const M: usize, const N: usize> Bits<[isize; M]> for [isize; N]

fn bits<const START: usize, const END: usize>(&self) -> [isize; M]

impl<const M: usize, const N: usize> Bits<[isize; M]> for [u8; N]

fn bits<const START: usize, const END: usize>(&self) -> [isize; M]

impl<const M: usize, const N: usize> Bits<[isize; M]> for [u16; N]

fn bits<const START: usize, const END: usize>(&self) -> [isize; M]

impl<const M: usize, const N: usize> Bits<[isize; M]> for [u32; N]

fn bits<const START: usize, const END: usize>(&self) -> [isize; M]

impl<const M: usize, const N: usize> Bits<[isize; M]> for [u64; N]

fn bits<const START: usize, const END: usize>(&self) -> [isize; M]

impl<const M: usize, const N: usize> Bits<[isize; M]> for [u128; N]

fn bits<const START: usize, const END: usize>(&self) -> [isize; M]

impl<const M: usize, const N: usize> Bits<[isize; M]> for [usize; N]

fn bits<const START: usize, const END: usize>(&self) -> [isize; M]

impl<const M: usize, const N: usize> Bits<[u8; M]> for [i8; N]

fn bits<const START: usize, const END: usize>(&self) -> [u8; M]

impl<const M: usize, const N: usize> Bits<[u8; M]> for [i16; N]

fn bits<const START: usize, const END: usize>(&self) -> [u8; M]

impl<const M: usize, const N: usize> Bits<[u8; M]> for [i32; N]

fn bits<const START: usize, const END: usize>(&self) -> [u8; M]

impl<const M: usize, const N: usize> Bits<[u8; M]> for [i64; N]

fn bits<const START: usize, const END: usize>(&self) -> [u8; M]

impl<const M: usize, const N: usize> Bits<[u8; M]> for [i128; N]

fn bits<const START: usize, const END: usize>(&self) -> [u8; M]

impl<const M: usize, const N: usize> Bits<[u8; M]> for [isize; N]

fn bits<const START: usize, const END: usize>(&self) -> [u8; M]

impl<const M: usize, const N: usize> Bits<[u8; M]> for [u8; N]

fn bits<const START: usize, const END: usize>(&self) -> [u8; M]

impl<const M: usize, const N: usize> Bits<[u8; M]> for [u16; N]

fn bits<const START: usize, const END: usize>(&self) -> [u8; M]

impl<const M: usize, const N: usize> Bits<[u8; M]> for [u32; N]

fn bits<const START: usize, const END: usize>(&self) -> [u8; M]

impl<const M: usize, const N: usize> Bits<[u8; M]> for [u64; N]

fn bits<const START: usize, const END: usize>(&self) -> [u8; M]

impl<const M: usize, const N: usize> Bits<[u8; M]> for [u128; N]

fn bits<const START: usize, const END: usize>(&self) -> [u8; M]

impl<const M: usize, const N: usize> Bits<[u8; M]> for [usize; N]

fn bits<const START: usize, const END: usize>(&self) -> [u8; M]

impl<const M: usize, const N: usize> Bits<[u16; M]> for [i8; N]

fn bits<const START: usize, const END: usize>(&self) -> [u16; M]

impl<const M: usize, const N: usize> Bits<[u16; M]> for [i16; N]

fn bits<const START: usize, const END: usize>(&self) -> [u16; M]

impl<const M: usize, const N: usize> Bits<[u16; M]> for [i32; N]

fn bits<const START: usize, const END: usize>(&self) -> [u16; M]

impl<const M: usize, const N: usize> Bits<[u16; M]> for [i64; N]

fn bits<const START: usize, const END: usize>(&self) -> [u16; M]

impl<const M: usize, const N: usize> Bits<[u16; M]> for [i128; N]

fn bits<const START: usize, const END: usize>(&self) -> [u16; M]

impl<const M: usize, const N: usize> Bits<[u16; M]> for [isize; N]

fn bits<const START: usize, const END: usize>(&self) -> [u16; M]

impl<const M: usize, const N: usize> Bits<[u16; M]> for [u8; N]

fn bits<const START: usize, const END: usize>(&self) -> [u16; M]

impl<const M: usize, const N: usize> Bits<[u16; M]> for [u16; N]

fn bits<const START: usize, const END: usize>(&self) -> [u16; M]

impl<const M: usize, const N: usize> Bits<[u16; M]> for [u32; N]

fn bits<const START: usize, const END: usize>(&self) -> [u16; M]

impl<const M: usize, const N: usize> Bits<[u16; M]> for [u64; N]

fn bits<const START: usize, const END: usize>(&self) -> [u16; M]

impl<const M: usize, const N: usize> Bits<[u16; M]> for [u128; N]

fn bits<const START: usize, const END: usize>(&self) -> [u16; M]

impl<const M: usize, const N: usize> Bits<[u16; M]> for [usize; N]

fn bits<const START: usize, const END: usize>(&self) -> [u16; M]

impl<const M: usize, const N: usize> Bits<[u32; M]> for [i8; N]

fn bits<const START: usize, const END: usize>(&self) -> [u32; M]

impl<const M: usize, const N: usize> Bits<[u32; M]> for [i16; N]

fn bits<const START: usize, const END: usize>(&self) -> [u32; M]

impl<const M: usize, const N: usize> Bits<[u32; M]> for [i32; N]

fn bits<const START: usize, const END: usize>(&self) -> [u32; M]

impl<const M: usize, const N: usize> Bits<[u32; M]> for [i64; N]

fn bits<const START: usize, const END: usize>(&self) -> [u32; M]

impl<const M: usize, const N: usize> Bits<[u32; M]> for [i128; N]

fn bits<const START: usize, const END: usize>(&self) -> [u32; M]

impl<const M: usize, const N: usize> Bits<[u32; M]> for [isize; N]

fn bits<const START: usize, const END: usize>(&self) -> [u32; M]

impl<const M: usize, const N: usize> Bits<[u32; M]> for [u8; N]

fn bits<const START: usize, const END: usize>(&self) -> [u32; M]

impl<const M: usize, const N: usize> Bits<[u32; M]> for [u16; N]

fn bits<const START: usize, const END: usize>(&self) -> [u32; M]

impl<const M: usize, const N: usize> Bits<[u32; M]> for [u32; N]

fn bits<const START: usize, const END: usize>(&self) -> [u32; M]

impl<const M: usize, const N: usize> Bits<[u32; M]> for [u64; N]

fn bits<const START: usize, const END: usize>(&self) -> [u32; M]

impl<const M: usize, const N: usize> Bits<[u32; M]> for [u128; N]

fn bits<const START: usize, const END: usize>(&self) -> [u32; M]

impl<const M: usize, const N: usize> Bits<[u32; M]> for [usize; N]

fn bits<const START: usize, const END: usize>(&self) -> [u32; M]

impl<const M: usize, const N: usize> Bits<[u64; M]> for [i8; N]

fn bits<const START: usize, const END: usize>(&self) -> [u64; M]

impl<const M: usize, const N: usize> Bits<[u64; M]> for [i16; N]

fn bits<const START: usize, const END: usize>(&self) -> [u64; M]

impl<const M: usize, const N: usize> Bits<[u64; M]> for [i32; N]

fn bits<const START: usize, const END: usize>(&self) -> [u64; M]

impl<const M: usize, const N: usize> Bits<[u64; M]> for [i64; N]

fn bits<const START: usize, const END: usize>(&self) -> [u64; M]

impl<const M: usize, const N: usize> Bits<[u64; M]> for [i128; N]

fn bits<const START: usize, const END: usize>(&self) -> [u64; M]

impl<const M: usize, const N: usize> Bits<[u64; M]> for [isize; N]

fn bits<const START: usize, const END: usize>(&self) -> [u64; M]

impl<const M: usize, const N: usize> Bits<[u64; M]> for [u8; N]

fn bits<const START: usize, const END: usize>(&self) -> [u64; M]

impl<const M: usize, const N: usize> Bits<[u64; M]> for [u16; N]

fn bits<const START: usize, const END: usize>(&self) -> [u64; M]

impl<const M: usize, const N: usize> Bits<[u64; M]> for [u32; N]

fn bits<const START: usize, const END: usize>(&self) -> [u64; M]

impl<const M: usize, const N: usize> Bits<[u64; M]> for [u64; N]

fn bits<const START: usize, const END: usize>(&self) -> [u64; M]

impl<const M: usize, const N: usize> Bits<[u64; M]> for [u128; N]

fn bits<const START: usize, const END: usize>(&self) -> [u64; M]

impl<const M: usize, const N: usize> Bits<[u64; M]> for [usize; N]

fn bits<const START: usize, const END: usize>(&self) -> [u64; M]

impl<const M: usize, const N: usize> Bits<[u128; M]> for [i8; N]

fn bits<const START: usize, const END: usize>(&self) -> [u128; M]

impl<const M: usize, const N: usize> Bits<[u128; M]> for [i16; N]

fn bits<const START: usize, const END: usize>(&self) -> [u128; M]

impl<const M: usize, const N: usize> Bits<[u128; M]> for [i32; N]

fn bits<const START: usize, const END: usize>(&self) -> [u128; M]

impl<const M: usize, const N: usize> Bits<[u128; M]> for [i64; N]

fn bits<const START: usize, const END: usize>(&self) -> [u128; M]

impl<const M: usize, const N: usize> Bits<[u128; M]> for [i128; N]

fn bits<const START: usize, const END: usize>(&self) -> [u128; M]

impl<const M: usize, const N: usize> Bits<[u128; M]> for [isize; N]

fn bits<const START: usize, const END: usize>(&self) -> [u128; M]

impl<const M: usize, const N: usize> Bits<[u128; M]> for [u8; N]

fn bits<const START: usize, const END: usize>(&self) -> [u128; M]

impl<const M: usize, const N: usize> Bits<[u128; M]> for [u16; N]

fn bits<const START: usize, const END: usize>(&self) -> [u128; M]

impl<const M: usize, const N: usize> Bits<[u128; M]> for [u32; N]

fn bits<const START: usize, const END: usize>(&self) -> [u128; M]

impl<const M: usize, const N: usize> Bits<[u128; M]> for [u64; N]

fn bits<const START: usize, const END: usize>(&self) -> [u128; M]

impl<const M: usize, const N: usize> Bits<[u128; M]> for [u128; N]

fn bits<const START: usize, const END: usize>(&self) -> [u128; M]

impl<const M: usize, const N: usize> Bits<[u128; M]> for [usize; N]

fn bits<const START: usize, const END: usize>(&self) -> [u128; M]

impl<const M: usize, const N: usize> Bits<[usize; M]> for [i8; N]

fn bits<const START: usize, const END: usize>(&self) -> [usize; M]

impl<const M: usize, const N: usize> Bits<[usize; M]> for [i16; N]

fn bits<const START: usize, const END: usize>(&self) -> [usize; M]

impl<const M: usize, const N: usize> Bits<[usize; M]> for [i32; N]

fn bits<const START: usize, const END: usize>(&self) -> [usize; M]

impl<const M: usize, const N: usize> Bits<[usize; M]> for [i64; N]

fn bits<const START: usize, const END: usize>(&self) -> [usize; M]

impl<const M: usize, const N: usize> Bits<[usize; M]> for [i128; N]

fn bits<const START: usize, const END: usize>(&self) -> [usize; M]

impl<const M: usize, const N: usize> Bits<[usize; M]> for [isize; N]

fn bits<const START: usize, const END: usize>(&self) -> [usize; M]

impl<const M: usize, const N: usize> Bits<[usize; M]> for [u8; N]

fn bits<const START: usize, const END: usize>(&self) -> [usize; M]

impl<const M: usize, const N: usize> Bits<[usize; M]> for [u16; N]

fn bits<const START: usize, const END: usize>(&self) -> [usize; M]

impl<const M: usize, const N: usize> Bits<[usize; M]> for [u32; N]

fn bits<const START: usize, const END: usize>(&self) -> [usize; M]

impl<const M: usize, const N: usize> Bits<[usize; M]> for [u64; N]

fn bits<const START: usize, const END: usize>(&self) -> [usize; M]

impl<const M: usize, const N: usize> Bits<[usize; M]> for [u128; N]

fn bits<const START: usize, const END: usize>(&self) -> [usize; M]

impl<const M: usize, const N: usize> Bits<[usize; M]> for [usize; N]

fn bits<const START: usize, const END: usize>(&self) -> [usize; M]

impl<const N: usize> Bits<i8> for [i8; N]

fn bits<const START: usize, const END: usize>(&self) -> i8

impl<const N: usize> Bits<i8> for [i16; N]

fn bits<const START: usize, const END: usize>(&self) -> i8

impl<const N: usize> Bits<i8> for [i32; N]

fn bits<const START: usize, const END: usize>(&self) -> i8

impl<const N: usize> Bits<i8> for [i64; N]

fn bits<const START: usize, const END: usize>(&self) -> i8

impl<const N: usize> Bits<i8> for [i128; N]

fn bits<const START: usize, const END: usize>(&self) -> i8

impl<const N: usize> Bits<i8> for [isize; N]

fn bits<const START: usize, const END: usize>(&self) -> i8

impl<const N: usize> Bits<i8> for [u8; N]

fn bits<const START: usize, const END: usize>(&self) -> i8

impl<const N: usize> Bits<i8> for [u16; N]

fn bits<const START: usize, const END: usize>(&self) -> i8

impl<const N: usize> Bits<i8> for [u32; N]

fn bits<const START: usize, const END: usize>(&self) -> i8

impl<const N: usize> Bits<i8> for [u64; N]

fn bits<const START: usize, const END: usize>(&self) -> i8

impl<const N: usize> Bits<i8> for [u128; N]

fn bits<const START: usize, const END: usize>(&self) -> i8

impl<const N: usize> Bits<i8> for [usize; N]

fn bits<const START: usize, const END: usize>(&self) -> i8

impl<const N: usize> Bits<i16> for [i8; N]

fn bits<const START: usize, const END: usize>(&self) -> i16

impl<const N: usize> Bits<i16> for [i16; N]

fn bits<const START: usize, const END: usize>(&self) -> i16

impl<const N: usize> Bits<i16> for [i32; N]

fn bits<const START: usize, const END: usize>(&self) -> i16

impl<const N: usize> Bits<i16> for [i64; N]

fn bits<const START: usize, const END: usize>(&self) -> i16

impl<const N: usize> Bits<i16> for [i128; N]

fn bits<const START: usize, const END: usize>(&self) -> i16

impl<const N: usize> Bits<i16> for [isize; N]

fn bits<const START: usize, const END: usize>(&self) -> i16

impl<const N: usize> Bits<i16> for [u8; N]

fn bits<const START: usize, const END: usize>(&self) -> i16

impl<const N: usize> Bits<i16> for [u16; N]

fn bits<const START: usize, const END: usize>(&self) -> i16

impl<const N: usize> Bits<i16> for [u32; N]

fn bits<const START: usize, const END: usize>(&self) -> i16

impl<const N: usize> Bits<i16> for [u64; N]

fn bits<const START: usize, const END: usize>(&self) -> i16

impl<const N: usize> Bits<i16> for [u128; N]

fn bits<const START: usize, const END: usize>(&self) -> i16

impl<const N: usize> Bits<i16> for [usize; N]

fn bits<const START: usize, const END: usize>(&self) -> i16

impl<const N: usize> Bits<i32> for [i8; N]

fn bits<const START: usize, const END: usize>(&self) -> i32

impl<const N: usize> Bits<i32> for [i16; N]

fn bits<const START: usize, const END: usize>(&self) -> i32

impl<const N: usize> Bits<i32> for [i32; N]

fn bits<const START: usize, const END: usize>(&self) -> i32

impl<const N: usize> Bits<i32> for [i64; N]

fn bits<const START: usize, const END: usize>(&self) -> i32

impl<const N: usize> Bits<i32> for [i128; N]

fn bits<const START: usize, const END: usize>(&self) -> i32

impl<const N: usize> Bits<i32> for [isize; N]

fn bits<const START: usize, const END: usize>(&self) -> i32

impl<const N: usize> Bits<i32> for [u8; N]

fn bits<const START: usize, const END: usize>(&self) -> i32

impl<const N: usize> Bits<i32> for [u16; N]

fn bits<const START: usize, const END: usize>(&self) -> i32

impl<const N: usize> Bits<i32> for [u32; N]

fn bits<const START: usize, const END: usize>(&self) -> i32

impl<const N: usize> Bits<i32> for [u64; N]

fn bits<const START: usize, const END: usize>(&self) -> i32

impl<const N: usize> Bits<i32> for [u128; N]

fn bits<const START: usize, const END: usize>(&self) -> i32

impl<const N: usize> Bits<i32> for [usize; N]

fn bits<const START: usize, const END: usize>(&self) -> i32

impl<const N: usize> Bits<i64> for [i8; N]

fn bits<const START: usize, const END: usize>(&self) -> i64

impl<const N: usize> Bits<i64> for [i16; N]

fn bits<const START: usize, const END: usize>(&self) -> i64

impl<const N: usize> Bits<i64> for [i32; N]

fn bits<const START: usize, const END: usize>(&self) -> i64

impl<const N: usize> Bits<i64> for [i64; N]

fn bits<const START: usize, const END: usize>(&self) -> i64

impl<const N: usize> Bits<i64> for [i128; N]

fn bits<const START: usize, const END: usize>(&self) -> i64

impl<const N: usize> Bits<i64> for [isize; N]

fn bits<const START: usize, const END: usize>(&self) -> i64

impl<const N: usize> Bits<i64> for [u8; N]

fn bits<const START: usize, const END: usize>(&self) -> i64

impl<const N: usize> Bits<i64> for [u16; N]

fn bits<const START: usize, const END: usize>(&self) -> i64

impl<const N: usize> Bits<i64> for [u32; N]

fn bits<const START: usize, const END: usize>(&self) -> i64

impl<const N: usize> Bits<i64> for [u64; N]

fn bits<const START: usize, const END: usize>(&self) -> i64

impl<const N: usize> Bits<i64> for [u128; N]

fn bits<const START: usize, const END: usize>(&self) -> i64

impl<const N: usize> Bits<i64> for [usize; N]

fn bits<const START: usize, const END: usize>(&self) -> i64

impl<const N: usize> Bits<i128> for [i8; N]

fn bits<const START: usize, const END: usize>(&self) -> i128

impl<const N: usize> Bits<i128> for [i16; N]

fn bits<const START: usize, const END: usize>(&self) -> i128

impl<const N: usize> Bits<i128> for [i32; N]

fn bits<const START: usize, const END: usize>(&self) -> i128

impl<const N: usize> Bits<i128> for [i64; N]

fn bits<const START: usize, const END: usize>(&self) -> i128

impl<const N: usize> Bits<i128> for [i128; N]

fn bits<const START: usize, const END: usize>(&self) -> i128

impl<const N: usize> Bits<i128> for [isize; N]

fn bits<const START: usize, const END: usize>(&self) -> i128

impl<const N: usize> Bits<i128> for [u8; N]

fn bits<const START: usize, const END: usize>(&self) -> i128

impl<const N: usize> Bits<i128> for [u16; N]

fn bits<const START: usize, const END: usize>(&self) -> i128

impl<const N: usize> Bits<i128> for [u32; N]

fn bits<const START: usize, const END: usize>(&self) -> i128

impl<const N: usize> Bits<i128> for [u64; N]

fn bits<const START: usize, const END: usize>(&self) -> i128

impl<const N: usize> Bits<i128> for [u128; N]

fn bits<const START: usize, const END: usize>(&self) -> i128

impl<const N: usize> Bits<i128> for [usize; N]

fn bits<const START: usize, const END: usize>(&self) -> i128

impl<const N: usize> Bits<isize> for [i8; N]

fn bits<const START: usize, const END: usize>(&self) -> isize

impl<const N: usize> Bits<isize> for [i16; N]

fn bits<const START: usize, const END: usize>(&self) -> isize

impl<const N: usize> Bits<isize> for [i32; N]

fn bits<const START: usize, const END: usize>(&self) -> isize

impl<const N: usize> Bits<isize> for [i64; N]

fn bits<const START: usize, const END: usize>(&self) -> isize

impl<const N: usize> Bits<isize> for [i128; N]

fn bits<const START: usize, const END: usize>(&self) -> isize

impl<const N: usize> Bits<isize> for [isize; N]

fn bits<const START: usize, const END: usize>(&self) -> isize

impl<const N: usize> Bits<isize> for [u8; N]

fn bits<const START: usize, const END: usize>(&self) -> isize

impl<const N: usize> Bits<isize> for [u16; N]

fn bits<const START: usize, const END: usize>(&self) -> isize

impl<const N: usize> Bits<isize> for [u32; N]

fn bits<const START: usize, const END: usize>(&self) -> isize

impl<const N: usize> Bits<isize> for [u64; N]

fn bits<const START: usize, const END: usize>(&self) -> isize

impl<const N: usize> Bits<isize> for [u128; N]

fn bits<const START: usize, const END: usize>(&self) -> isize

impl<const N: usize> Bits<isize> for [usize; N]

fn bits<const START: usize, const END: usize>(&self) -> isize

impl<const N: usize> Bits<u8> for [i8; N]

fn bits<const START: usize, const END: usize>(&self) -> u8

impl<const N: usize> Bits<u8> for [i16; N]

fn bits<const START: usize, const END: usize>(&self) -> u8

impl<const N: usize> Bits<u8> for [i32; N]

fn bits<const START: usize, const END: usize>(&self) -> u8

impl<const N: usize> Bits<u8> for [i64; N]

fn bits<const START: usize, const END: usize>(&self) -> u8

impl<const N: usize> Bits<u8> for [i128; N]

fn bits<const START: usize, const END: usize>(&self) -> u8

impl<const N: usize> Bits<u8> for [isize; N]

fn bits<const START: usize, const END: usize>(&self) -> u8

impl<const N: usize> Bits<u8> for [u8; N]

fn bits<const START: usize, const END: usize>(&self) -> u8

impl<const N: usize> Bits<u8> for [u16; N]

fn bits<const START: usize, const END: usize>(&self) -> u8

impl<const N: usize> Bits<u8> for [u32; N]

fn bits<const START: usize, const END: usize>(&self) -> u8

impl<const N: usize> Bits<u8> for [u64; N]

fn bits<const START: usize, const END: usize>(&self) -> u8

impl<const N: usize> Bits<u8> for [u128; N]

fn bits<const START: usize, const END: usize>(&self) -> u8

impl<const N: usize> Bits<u8> for [usize; N]

fn bits<const START: usize, const END: usize>(&self) -> u8

impl<const N: usize> Bits<u16> for [i8; N]

fn bits<const START: usize, const END: usize>(&self) -> u16

impl<const N: usize> Bits<u16> for [i16; N]

fn bits<const START: usize, const END: usize>(&self) -> u16

impl<const N: usize> Bits<u16> for [i32; N]

fn bits<const START: usize, const END: usize>(&self) -> u16

impl<const N: usize> Bits<u16> for [i64; N]

fn bits<const START: usize, const END: usize>(&self) -> u16

impl<const N: usize> Bits<u16> for [i128; N]

fn bits<const START: usize, const END: usize>(&self) -> u16

impl<const N: usize> Bits<u16> for [isize; N]

fn bits<const START: usize, const END: usize>(&self) -> u16

impl<const N: usize> Bits<u16> for [u8; N]

fn bits<const START: usize, const END: usize>(&self) -> u16

impl<const N: usize> Bits<u16> for [u16; N]

fn bits<const START: usize, const END: usize>(&self) -> u16

impl<const N: usize> Bits<u16> for [u32; N]

fn bits<const START: usize, const END: usize>(&self) -> u16

impl<const N: usize> Bits<u16> for [u64; N]

fn bits<const START: usize, const END: usize>(&self) -> u16

impl<const N: usize> Bits<u16> for [u128; N]

fn bits<const START: usize, const END: usize>(&self) -> u16

impl<const N: usize> Bits<u16> for [usize; N]

fn bits<const START: usize, const END: usize>(&self) -> u16

impl<const N: usize> Bits<u32> for [i8; N]

fn bits<const START: usize, const END: usize>(&self) -> u32

impl<const N: usize> Bits<u32> for [i16; N]

fn bits<const START: usize, const END: usize>(&self) -> u32

impl<const N: usize> Bits<u32> for [i32; N]

fn bits<const START: usize, const END: usize>(&self) -> u32

impl<const N: usize> Bits<u32> for [i64; N]

fn bits<const START: usize, const END: usize>(&self) -> u32

impl<const N: usize> Bits<u32> for [i128; N]

fn bits<const START: usize, const END: usize>(&self) -> u32

impl<const N: usize> Bits<u32> for [isize; N]

fn bits<const START: usize, const END: usize>(&self) -> u32

impl<const N: usize> Bits<u32> for [u8; N]

fn bits<const START: usize, const END: usize>(&self) -> u32

impl<const N: usize> Bits<u32> for [u16; N]

fn bits<const START: usize, const END: usize>(&self) -> u32

impl<const N: usize> Bits<u32> for [u32; N]

fn bits<const START: usize, const END: usize>(&self) -> u32

impl<const N: usize> Bits<u32> for [u64; N]

fn bits<const START: usize, const END: usize>(&self) -> u32

impl<const N: usize> Bits<u32> for [u128; N]

fn bits<const START: usize, const END: usize>(&self) -> u32

impl<const N: usize> Bits<u32> for [usize; N]

fn bits<const START: usize, const END: usize>(&self) -> u32

impl<const N: usize> Bits<u64> for [i8; N]

fn bits<const START: usize, const END: usize>(&self) -> u64

impl<const N: usize> Bits<u64> for [i16; N]

fn bits<const START: usize, const END: usize>(&self) -> u64

impl<const N: usize> Bits<u64> for [i32; N]

fn bits<const START: usize, const END: usize>(&self) -> u64

impl<const N: usize> Bits<u64> for [i64; N]

fn bits<const START: usize, const END: usize>(&self) -> u64

impl<const N: usize> Bits<u64> for [i128; N]

fn bits<const START: usize, const END: usize>(&self) -> u64

impl<const N: usize> Bits<u64> for [isize; N]

fn bits<const START: usize, const END: usize>(&self) -> u64

impl<const N: usize> Bits<u64> for [u8; N]

fn bits<const START: usize, const END: usize>(&self) -> u64

impl<const N: usize> Bits<u64> for [u16; N]

fn bits<const START: usize, const END: usize>(&self) -> u64

impl<const N: usize> Bits<u64> for [u32; N]

fn bits<const START: usize, const END: usize>(&self) -> u64

impl<const N: usize> Bits<u64> for [u64; N]

fn bits<const START: usize, const END: usize>(&self) -> u64

impl<const N: usize> Bits<u64> for [u128; N]

fn bits<const START: usize, const END: usize>(&self) -> u64

impl<const N: usize> Bits<u64> for [usize; N]

fn bits<const START: usize, const END: usize>(&self) -> u64

impl<const N: usize> Bits<u128> for [i8; N]

fn bits<const START: usize, const END: usize>(&self) -> u128

impl<const N: usize> Bits<u128> for [i16; N]

fn bits<const START: usize, const END: usize>(&self) -> u128

impl<const N: usize> Bits<u128> for [i32; N]

fn bits<const START: usize, const END: usize>(&self) -> u128

impl<const N: usize> Bits<u128> for [i64; N]

fn bits<const START: usize, const END: usize>(&self) -> u128

impl<const N: usize> Bits<u128> for [i128; N]

fn bits<const START: usize, const END: usize>(&self) -> u128

impl<const N: usize> Bits<u128> for [isize; N]

fn bits<const START: usize, const END: usize>(&self) -> u128

impl<const N: usize> Bits<u128> for [u8; N]

fn bits<const START: usize, const END: usize>(&self) -> u128

impl<const N: usize> Bits<u128> for [u16; N]

fn bits<const START: usize, const END: usize>(&self) -> u128

impl<const N: usize> Bits<u128> for [u32; N]

fn bits<const START: usize, const END: usize>(&self) -> u128

impl<const N: usize> Bits<u128> for [u64; N]

fn bits<const START: usize, const END: usize>(&self) -> u128

impl<const N: usize> Bits<u128> for [u128; N]

fn bits<const START: usize, const END: usize>(&self) -> u128

impl<const N: usize> Bits<u128> for [usize; N]

fn bits<const START: usize, const END: usize>(&self) -> u128

impl<const N: usize> Bits<usize> for [i8; N]

fn bits<const START: usize, const END: usize>(&self) -> usize

impl<const N: usize> Bits<usize> for [i16; N]

fn bits<const START: usize, const END: usize>(&self) -> usize

impl<const N: usize> Bits<usize> for [i32; N]

fn bits<const START: usize, const END: usize>(&self) -> usize

impl<const N: usize> Bits<usize> for [i64; N]

fn bits<const START: usize, const END: usize>(&self) -> usize

impl<const N: usize> Bits<usize> for [i128; N]

fn bits<const START: usize, const END: usize>(&self) -> usize

impl<const N: usize> Bits<usize> for [isize; N]

fn bits<const START: usize, const END: usize>(&self) -> usize

impl<const N: usize> Bits<usize> for [u8; N]

fn bits<const START: usize, const END: usize>(&self) -> usize

impl<const N: usize> Bits<usize> for [u16; N]

fn bits<const START: usize, const END: usize>(&self) -> usize

impl<const N: usize> Bits<usize> for [u32; N]

fn bits<const START: usize, const END: usize>(&self) -> usize

impl<const N: usize> Bits<usize> for [u64; N]

fn bits<const START: usize, const END: usize>(&self) -> usize

impl<const N: usize> Bits<usize> for [u128; N]

fn bits<const START: usize, const END: usize>(&self) -> usize

impl<const N: usize> Bits<usize> for [usize; N]

fn bits<const START: usize, const END: usize>(&self) -> usize

Implementors