Trait proc_bitfield::WithBits

pub trait WithBits<T> {
    // Required method
    fn with_bits<const START: usize, const END: usize>(self, value: T) -> Self;
}

Return a value with a range of bits modified.

Required Methods

fn with_bits<const START: usize, const END: usize>(self, value: T) -> Self

Returns self with the the START..END bit range (with END excluded) set to the given value of type T.

Object Safety

This trait is not object safe.

Implementations on Foreign Types

impl WithBits<i8> for i8

fn with_bits<const START: usize, const END: usize>(self, value: i8) -> Self

impl WithBits<i8> for i16

fn with_bits<const START: usize, const END: usize>(self, value: i8) -> Self

impl WithBits<i8> for i32

fn with_bits<const START: usize, const END: usize>(self, value: i8) -> Self

impl WithBits<i8> for i64

fn with_bits<const START: usize, const END: usize>(self, value: i8) -> Self

impl WithBits<i8> for i128

fn with_bits<const START: usize, const END: usize>(self, value: i8) -> Self

impl WithBits<i8> for isize

fn with_bits<const START: usize, const END: usize>(self, value: i8) -> Self

impl WithBits<i8> for u8

fn with_bits<const START: usize, const END: usize>(self, value: i8) -> Self

impl WithBits<i8> for u16

fn with_bits<const START: usize, const END: usize>(self, value: i8) -> Self

impl WithBits<i8> for u32

fn with_bits<const START: usize, const END: usize>(self, value: i8) -> Self

impl WithBits<i8> for u64

fn with_bits<const START: usize, const END: usize>(self, value: i8) -> Self

impl WithBits<i8> for u128

fn with_bits<const START: usize, const END: usize>(self, value: i8) -> Self

impl WithBits<i8> for usize

fn with_bits<const START: usize, const END: usize>(self, value: i8) -> Self

impl WithBits<i16> for i8

fn with_bits<const START: usize, const END: usize>(self, value: i16) -> Self

impl WithBits<i16> for i16

fn with_bits<const START: usize, const END: usize>(self, value: i16) -> Self

impl WithBits<i16> for i32

fn with_bits<const START: usize, const END: usize>(self, value: i16) -> Self

impl WithBits<i16> for i64

fn with_bits<const START: usize, const END: usize>(self, value: i16) -> Self

impl WithBits<i16> for i128

fn with_bits<const START: usize, const END: usize>(self, value: i16) -> Self

impl WithBits<i16> for isize

fn with_bits<const START: usize, const END: usize>(self, value: i16) -> Self

impl WithBits<i16> for u8

fn with_bits<const START: usize, const END: usize>(self, value: i16) -> Self

impl WithBits<i16> for u16

fn with_bits<const START: usize, const END: usize>(self, value: i16) -> Self

impl WithBits<i16> for u32

fn with_bits<const START: usize, const END: usize>(self, value: i16) -> Self

impl WithBits<i16> for u64

fn with_bits<const START: usize, const END: usize>(self, value: i16) -> Self

impl WithBits<i16> for u128

fn with_bits<const START: usize, const END: usize>(self, value: i16) -> Self

impl WithBits<i16> for usize

fn with_bits<const START: usize, const END: usize>(self, value: i16) -> Self

impl WithBits<i32> for i8

fn with_bits<const START: usize, const END: usize>(self, value: i32) -> Self

impl WithBits<i32> for i16

fn with_bits<const START: usize, const END: usize>(self, value: i32) -> Self

impl WithBits<i32> for i32

fn with_bits<const START: usize, const END: usize>(self, value: i32) -> Self

impl WithBits<i32> for i64

fn with_bits<const START: usize, const END: usize>(self, value: i32) -> Self

impl WithBits<i32> for i128

fn with_bits<const START: usize, const END: usize>(self, value: i32) -> Self

impl WithBits<i32> for isize

fn with_bits<const START: usize, const END: usize>(self, value: i32) -> Self

impl WithBits<i32> for u8

fn with_bits<const START: usize, const END: usize>(self, value: i32) -> Self

impl WithBits<i32> for u16

fn with_bits<const START: usize, const END: usize>(self, value: i32) -> Self

impl WithBits<i32> for u32

fn with_bits<const START: usize, const END: usize>(self, value: i32) -> Self

impl WithBits<i32> for u64

fn with_bits<const START: usize, const END: usize>(self, value: i32) -> Self

impl WithBits<i32> for u128

fn with_bits<const START: usize, const END: usize>(self, value: i32) -> Self

impl WithBits<i32> for usize

fn with_bits<const START: usize, const END: usize>(self, value: i32) -> Self

impl WithBits<i64> for i8

fn with_bits<const START: usize, const END: usize>(self, value: i64) -> Self

impl WithBits<i64> for i16

fn with_bits<const START: usize, const END: usize>(self, value: i64) -> Self

impl WithBits<i64> for i32

fn with_bits<const START: usize, const END: usize>(self, value: i64) -> Self

impl WithBits<i64> for i64

fn with_bits<const START: usize, const END: usize>(self, value: i64) -> Self

impl WithBits<i64> for i128

fn with_bits<const START: usize, const END: usize>(self, value: i64) -> Self

impl WithBits<i64> for isize

fn with_bits<const START: usize, const END: usize>(self, value: i64) -> Self

impl WithBits<i64> for u8

fn with_bits<const START: usize, const END: usize>(self, value: i64) -> Self

impl WithBits<i64> for u16

fn with_bits<const START: usize, const END: usize>(self, value: i64) -> Self

impl WithBits<i64> for u32

fn with_bits<const START: usize, const END: usize>(self, value: i64) -> Self

impl WithBits<i64> for u64

fn with_bits<const START: usize, const END: usize>(self, value: i64) -> Self

impl WithBits<i64> for u128

fn with_bits<const START: usize, const END: usize>(self, value: i64) -> Self

impl WithBits<i64> for usize

fn with_bits<const START: usize, const END: usize>(self, value: i64) -> Self

impl WithBits<i128> for i8

fn with_bits<const START: usize, const END: usize>(self, value: i128) -> Self

impl WithBits<i128> for i16

fn with_bits<const START: usize, const END: usize>(self, value: i128) -> Self

impl WithBits<i128> for i32

fn with_bits<const START: usize, const END: usize>(self, value: i128) -> Self

impl WithBits<i128> for i64

fn with_bits<const START: usize, const END: usize>(self, value: i128) -> Self

impl WithBits<i128> for i128

fn with_bits<const START: usize, const END: usize>(self, value: i128) -> Self

impl WithBits<i128> for isize

fn with_bits<const START: usize, const END: usize>(self, value: i128) -> Self

impl WithBits<i128> for u8

fn with_bits<const START: usize, const END: usize>(self, value: i128) -> Self

impl WithBits<i128> for u16

fn with_bits<const START: usize, const END: usize>(self, value: i128) -> Self

impl WithBits<i128> for u32

fn with_bits<const START: usize, const END: usize>(self, value: i128) -> Self

impl WithBits<i128> for u64

fn with_bits<const START: usize, const END: usize>(self, value: i128) -> Self

impl WithBits<i128> for u128

fn with_bits<const START: usize, const END: usize>(self, value: i128) -> Self

impl WithBits<i128> for usize

fn with_bits<const START: usize, const END: usize>(self, value: i128) -> Self

impl WithBits<isize> for i8

fn with_bits<const START: usize, const END: usize>(self, value: isize) -> Self

impl WithBits<isize> for i16

fn with_bits<const START: usize, const END: usize>(self, value: isize) -> Self

impl WithBits<isize> for i32

fn with_bits<const START: usize, const END: usize>(self, value: isize) -> Self

impl WithBits<isize> for i64

fn with_bits<const START: usize, const END: usize>(self, value: isize) -> Self

impl WithBits<isize> for i128

fn with_bits<const START: usize, const END: usize>(self, value: isize) -> Self

impl WithBits<isize> for isize

fn with_bits<const START: usize, const END: usize>(self, value: isize) -> Self

impl WithBits<isize> for u8

fn with_bits<const START: usize, const END: usize>(self, value: isize) -> Self

impl WithBits<isize> for u16

fn with_bits<const START: usize, const END: usize>(self, value: isize) -> Self

impl WithBits<isize> for u32

fn with_bits<const START: usize, const END: usize>(self, value: isize) -> Self

impl WithBits<isize> for u64

fn with_bits<const START: usize, const END: usize>(self, value: isize) -> Self

impl WithBits<isize> for u128

fn with_bits<const START: usize, const END: usize>(self, value: isize) -> Self

impl WithBits<isize> for usize

fn with_bits<const START: usize, const END: usize>(self, value: isize) -> Self

impl WithBits<u8> for i8

fn with_bits<const START: usize, const END: usize>(self, value: u8) -> Self

impl WithBits<u8> for i16

fn with_bits<const START: usize, const END: usize>(self, value: u8) -> Self

impl WithBits<u8> for i32

fn with_bits<const START: usize, const END: usize>(self, value: u8) -> Self

impl WithBits<u8> for i64

fn with_bits<const START: usize, const END: usize>(self, value: u8) -> Self

impl WithBits<u8> for i128

fn with_bits<const START: usize, const END: usize>(self, value: u8) -> Self

impl WithBits<u8> for isize

fn with_bits<const START: usize, const END: usize>(self, value: u8) -> Self

impl WithBits<u8> for u8

fn with_bits<const START: usize, const END: usize>(self, value: u8) -> Self

impl WithBits<u8> for u16

fn with_bits<const START: usize, const END: usize>(self, value: u8) -> Self

impl WithBits<u8> for u32

fn with_bits<const START: usize, const END: usize>(self, value: u8) -> Self

impl WithBits<u8> for u64

fn with_bits<const START: usize, const END: usize>(self, value: u8) -> Self

impl WithBits<u8> for u128

fn with_bits<const START: usize, const END: usize>(self, value: u8) -> Self

impl WithBits<u8> for usize

fn with_bits<const START: usize, const END: usize>(self, value: u8) -> Self

impl WithBits<u16> for i8

fn with_bits<const START: usize, const END: usize>(self, value: u16) -> Self

impl WithBits<u16> for i16

fn with_bits<const START: usize, const END: usize>(self, value: u16) -> Self

impl WithBits<u16> for i32

fn with_bits<const START: usize, const END: usize>(self, value: u16) -> Self

impl WithBits<u16> for i64

fn with_bits<const START: usize, const END: usize>(self, value: u16) -> Self

impl WithBits<u16> for i128

fn with_bits<const START: usize, const END: usize>(self, value: u16) -> Self

impl WithBits<u16> for isize

fn with_bits<const START: usize, const END: usize>(self, value: u16) -> Self

impl WithBits<u16> for u8

fn with_bits<const START: usize, const END: usize>(self, value: u16) -> Self

impl WithBits<u16> for u16

fn with_bits<const START: usize, const END: usize>(self, value: u16) -> Self

impl WithBits<u16> for u32

fn with_bits<const START: usize, const END: usize>(self, value: u16) -> Self

impl WithBits<u16> for u64

fn with_bits<const START: usize, const END: usize>(self, value: u16) -> Self

impl WithBits<u16> for u128

fn with_bits<const START: usize, const END: usize>(self, value: u16) -> Self

impl WithBits<u16> for usize

fn with_bits<const START: usize, const END: usize>(self, value: u16) -> Self

impl WithBits<u32> for i8

fn with_bits<const START: usize, const END: usize>(self, value: u32) -> Self

impl WithBits<u32> for i16

fn with_bits<const START: usize, const END: usize>(self, value: u32) -> Self

impl WithBits<u32> for i32

fn with_bits<const START: usize, const END: usize>(self, value: u32) -> Self

impl WithBits<u32> for i64

fn with_bits<const START: usize, const END: usize>(self, value: u32) -> Self

impl WithBits<u32> for i128

fn with_bits<const START: usize, const END: usize>(self, value: u32) -> Self

impl WithBits<u32> for isize

fn with_bits<const START: usize, const END: usize>(self, value: u32) -> Self

impl WithBits<u32> for u8

fn with_bits<const START: usize, const END: usize>(self, value: u32) -> Self

impl WithBits<u32> for u16

fn with_bits<const START: usize, const END: usize>(self, value: u32) -> Self

impl WithBits<u32> for u32

fn with_bits<const START: usize, const END: usize>(self, value: u32) -> Self

impl WithBits<u32> for u64

fn with_bits<const START: usize, const END: usize>(self, value: u32) -> Self

impl WithBits<u32> for u128

fn with_bits<const START: usize, const END: usize>(self, value: u32) -> Self

impl WithBits<u32> for usize

fn with_bits<const START: usize, const END: usize>(self, value: u32) -> Self

impl WithBits<u64> for i8

fn with_bits<const START: usize, const END: usize>(self, value: u64) -> Self

impl WithBits<u64> for i16

fn with_bits<const START: usize, const END: usize>(self, value: u64) -> Self

impl WithBits<u64> for i32

fn with_bits<const START: usize, const END: usize>(self, value: u64) -> Self

impl WithBits<u64> for i64

fn with_bits<const START: usize, const END: usize>(self, value: u64) -> Self

impl WithBits<u64> for i128

fn with_bits<const START: usize, const END: usize>(self, value: u64) -> Self

impl WithBits<u64> for isize

fn with_bits<const START: usize, const END: usize>(self, value: u64) -> Self

impl WithBits<u64> for u8

fn with_bits<const START: usize, const END: usize>(self, value: u64) -> Self

impl WithBits<u64> for u16

fn with_bits<const START: usize, const END: usize>(self, value: u64) -> Self

impl WithBits<u64> for u32

fn with_bits<const START: usize, const END: usize>(self, value: u64) -> Self

impl WithBits<u64> for u64

fn with_bits<const START: usize, const END: usize>(self, value: u64) -> Self

impl WithBits<u64> for u128

fn with_bits<const START: usize, const END: usize>(self, value: u64) -> Self

impl WithBits<u64> for usize

fn with_bits<const START: usize, const END: usize>(self, value: u64) -> Self

impl WithBits<u128> for i8

fn with_bits<const START: usize, const END: usize>(self, value: u128) -> Self

impl WithBits<u128> for i16

fn with_bits<const START: usize, const END: usize>(self, value: u128) -> Self

impl WithBits<u128> for i32

fn with_bits<const START: usize, const END: usize>(self, value: u128) -> Self

impl WithBits<u128> for i64

fn with_bits<const START: usize, const END: usize>(self, value: u128) -> Self

impl WithBits<u128> for i128

fn with_bits<const START: usize, const END: usize>(self, value: u128) -> Self

impl WithBits<u128> for isize

fn with_bits<const START: usize, const END: usize>(self, value: u128) -> Self

impl WithBits<u128> for u8

fn with_bits<const START: usize, const END: usize>(self, value: u128) -> Self

impl WithBits<u128> for u16

fn with_bits<const START: usize, const END: usize>(self, value: u128) -> Self

impl WithBits<u128> for u32

fn with_bits<const START: usize, const END: usize>(self, value: u128) -> Self

impl WithBits<u128> for u64

fn with_bits<const START: usize, const END: usize>(self, value: u128) -> Self

impl WithBits<u128> for u128

fn with_bits<const START: usize, const END: usize>(self, value: u128) -> Self

impl WithBits<u128> for usize

fn with_bits<const START: usize, const END: usize>(self, value: u128) -> Self

impl WithBits<usize> for i8

fn with_bits<const START: usize, const END: usize>(self, value: usize) -> Self

impl WithBits<usize> for i16

fn with_bits<const START: usize, const END: usize>(self, value: usize) -> Self

impl WithBits<usize> for i32

fn with_bits<const START: usize, const END: usize>(self, value: usize) -> Self

impl WithBits<usize> for i64

fn with_bits<const START: usize, const END: usize>(self, value: usize) -> Self

impl WithBits<usize> for i128

fn with_bits<const START: usize, const END: usize>(self, value: usize) -> Self

impl WithBits<usize> for isize

fn with_bits<const START: usize, const END: usize>(self, value: usize) -> Self

impl WithBits<usize> for u8

fn with_bits<const START: usize, const END: usize>(self, value: usize) -> Self

impl WithBits<usize> for u16

fn with_bits<const START: usize, const END: usize>(self, value: usize) -> Self

impl WithBits<usize> for u32

fn with_bits<const START: usize, const END: usize>(self, value: usize) -> Self

impl WithBits<usize> for u64

fn with_bits<const START: usize, const END: usize>(self, value: usize) -> Self

impl WithBits<usize> for u128

fn with_bits<const START: usize, const END: usize>(self, value: usize) -> Self

impl WithBits<usize> for usize

fn with_bits<const START: usize, const END: usize>(self, value: usize) -> Self

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

fn with_bits<const START: usize, const END: usize>(self, value: [i8; M]) -> Self

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

fn with_bits<const START: usize, const END: usize>(self, value: [i8; M]) -> Self

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

fn with_bits<const START: usize, const END: usize>(self, value: [i8; M]) -> Self

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

fn with_bits<const START: usize, const END: usize>(self, value: [i8; M]) -> Self

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

fn with_bits<const START: usize, const END: usize>(self, value: [i8; M]) -> Self

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

fn with_bits<const START: usize, const END: usize>(self, value: [i8; M]) -> Self

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

fn with_bits<const START: usize, const END: usize>(self, value: [i8; M]) -> Self

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

fn with_bits<const START: usize, const END: usize>(self, value: [i8; M]) -> Self

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

fn with_bits<const START: usize, const END: usize>(self, value: [i8; M]) -> Self

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

fn with_bits<const START: usize, const END: usize>(self, value: [i8; M]) -> Self

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

fn with_bits<const START: usize, const END: usize>(self, value: [i8; M]) -> Self

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

fn with_bits<const START: usize, const END: usize>(self, value: [i8; M]) -> Self

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

fn with_bits<const START: usize, const END: usize>( self, value: [i16; M] ) -> Self

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

fn with_bits<const START: usize, const END: usize>( self, value: [i16; M] ) -> Self

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

fn with_bits<const START: usize, const END: usize>( self, value: [i16; M] ) -> Self

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

fn with_bits<const START: usize, const END: usize>( self, value: [i16; M] ) -> Self

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

fn with_bits<const START: usize, const END: usize>( self, value: [i16; M] ) -> Self

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

fn with_bits<const START: usize, const END: usize>( self, value: [i16; M] ) -> Self

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

fn with_bits<const START: usize, const END: usize>( self, value: [i16; M] ) -> Self

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

fn with_bits<const START: usize, const END: usize>( self, value: [i16; M] ) -> Self

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

fn with_bits<const START: usize, const END: usize>( self, value: [i16; M] ) -> Self

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

fn with_bits<const START: usize, const END: usize>( self, value: [i16; M] ) -> Self

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

fn with_bits<const START: usize, const END: usize>( self, value: [i16; M] ) -> Self

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

fn with_bits<const START: usize, const END: usize>( self, value: [i16; M] ) -> Self

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

fn with_bits<const START: usize, const END: usize>( self, value: [i32; M] ) -> Self

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

fn with_bits<const START: usize, const END: usize>( self, value: [i32; M] ) -> Self

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

fn with_bits<const START: usize, const END: usize>( self, value: [i32; M] ) -> Self

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

fn with_bits<const START: usize, const END: usize>( self, value: [i32; M] ) -> Self

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

fn with_bits<const START: usize, const END: usize>( self, value: [i32; M] ) -> Self

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

fn with_bits<const START: usize, const END: usize>( self, value: [i32; M] ) -> Self

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

fn with_bits<const START: usize, const END: usize>( self, value: [i32; M] ) -> Self

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

fn with_bits<const START: usize, const END: usize>( self, value: [i32; M] ) -> Self

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

fn with_bits<const START: usize, const END: usize>( self, value: [i32; M] ) -> Self

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

fn with_bits<const START: usize, const END: usize>( self, value: [i32; M] ) -> Self

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

fn with_bits<const START: usize, const END: usize>( self, value: [i32; M] ) -> Self

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

fn with_bits<const START: usize, const END: usize>( self, value: [i32; M] ) -> Self

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

fn with_bits<const START: usize, const END: usize>( self, value: [i64; M] ) -> Self

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

fn with_bits<const START: usize, const END: usize>( self, value: [i64; M] ) -> Self

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

fn with_bits<const START: usize, const END: usize>( self, value: [i64; M] ) -> Self

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

fn with_bits<const START: usize, const END: usize>( self, value: [i64; M] ) -> Self

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

fn with_bits<const START: usize, const END: usize>( self, value: [i64; M] ) -> Self

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

fn with_bits<const START: usize, const END: usize>( self, value: [i64; M] ) -> Self

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

fn with_bits<const START: usize, const END: usize>( self, value: [i64; M] ) -> Self

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

fn with_bits<const START: usize, const END: usize>( self, value: [i64; M] ) -> Self

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

fn with_bits<const START: usize, const END: usize>( self, value: [i64; M] ) -> Self

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

fn with_bits<const START: usize, const END: usize>( self, value: [i64; M] ) -> Self

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

fn with_bits<const START: usize, const END: usize>( self, value: [i64; M] ) -> Self

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

fn with_bits<const START: usize, const END: usize>( self, value: [i64; M] ) -> Self

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

fn with_bits<const START: usize, const END: usize>( self, value: [i128; M] ) -> Self

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

fn with_bits<const START: usize, const END: usize>( self, value: [i128; M] ) -> Self

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

fn with_bits<const START: usize, const END: usize>( self, value: [i128; M] ) -> Self

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

fn with_bits<const START: usize, const END: usize>( self, value: [i128; M] ) -> Self

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

fn with_bits<const START: usize, const END: usize>( self, value: [i128; M] ) -> Self

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

fn with_bits<const START: usize, const END: usize>( self, value: [i128; M] ) -> Self

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

fn with_bits<const START: usize, const END: usize>( self, value: [i128; M] ) -> Self

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

fn with_bits<const START: usize, const END: usize>( self, value: [i128; M] ) -> Self

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

fn with_bits<const START: usize, const END: usize>( self, value: [i128; M] ) -> Self

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

fn with_bits<const START: usize, const END: usize>( self, value: [i128; M] ) -> Self

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

fn with_bits<const START: usize, const END: usize>( self, value: [i128; M] ) -> Self

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

fn with_bits<const START: usize, const END: usize>( self, value: [i128; M] ) -> Self

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

fn with_bits<const START: usize, const END: usize>( self, value: [isize; M] ) -> Self

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

fn with_bits<const START: usize, const END: usize>( self, value: [isize; M] ) -> Self

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

fn with_bits<const START: usize, const END: usize>( self, value: [isize; M] ) -> Self

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

fn with_bits<const START: usize, const END: usize>( self, value: [isize; M] ) -> Self

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

fn with_bits<const START: usize, const END: usize>( self, value: [isize; M] ) -> Self

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

fn with_bits<const START: usize, const END: usize>( self, value: [isize; M] ) -> Self

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

fn with_bits<const START: usize, const END: usize>( self, value: [isize; M] ) -> Self

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

fn with_bits<const START: usize, const END: usize>( self, value: [isize; M] ) -> Self

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

fn with_bits<const START: usize, const END: usize>( self, value: [isize; M] ) -> Self

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

fn with_bits<const START: usize, const END: usize>( self, value: [isize; M] ) -> Self

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

fn with_bits<const START: usize, const END: usize>( self, value: [isize; M] ) -> Self

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

fn with_bits<const START: usize, const END: usize>( self, value: [isize; M] ) -> Self

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

fn with_bits<const START: usize, const END: usize>(self, value: [u8; M]) -> Self

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

fn with_bits<const START: usize, const END: usize>(self, value: [u8; M]) -> Self

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

fn with_bits<const START: usize, const END: usize>(self, value: [u8; M]) -> Self

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

fn with_bits<const START: usize, const END: usize>(self, value: [u8; M]) -> Self

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

fn with_bits<const START: usize, const END: usize>(self, value: [u8; M]) -> Self

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

fn with_bits<const START: usize, const END: usize>(self, value: [u8; M]) -> Self

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

fn with_bits<const START: usize, const END: usize>(self, value: [u8; M]) -> Self

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

fn with_bits<const START: usize, const END: usize>(self, value: [u8; M]) -> Self

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

fn with_bits<const START: usize, const END: usize>(self, value: [u8; M]) -> Self

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

fn with_bits<const START: usize, const END: usize>(self, value: [u8; M]) -> Self

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

fn with_bits<const START: usize, const END: usize>(self, value: [u8; M]) -> Self

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

fn with_bits<const START: usize, const END: usize>(self, value: [u8; M]) -> Self

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

fn with_bits<const START: usize, const END: usize>( self, value: [u16; M] ) -> Self

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

fn with_bits<const START: usize, const END: usize>( self, value: [u16; M] ) -> Self

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

fn with_bits<const START: usize, const END: usize>( self, value: [u16; M] ) -> Self

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

fn with_bits<const START: usize, const END: usize>( self, value: [u16; M] ) -> Self

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

fn with_bits<const START: usize, const END: usize>( self, value: [u16; M] ) -> Self

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

fn with_bits<const START: usize, const END: usize>( self, value: [u16; M] ) -> Self

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

fn with_bits<const START: usize, const END: usize>( self, value: [u16; M] ) -> Self

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

fn with_bits<const START: usize, const END: usize>( self, value: [u16; M] ) -> Self

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

fn with_bits<const START: usize, const END: usize>( self, value: [u16; M] ) -> Self

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

fn with_bits<const START: usize, const END: usize>( self, value: [u16; M] ) -> Self

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

fn with_bits<const START: usize, const END: usize>( self, value: [u16; M] ) -> Self

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

fn with_bits<const START: usize, const END: usize>( self, value: [u16; M] ) -> Self

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

fn with_bits<const START: usize, const END: usize>( self, value: [u32; M] ) -> Self

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

fn with_bits<const START: usize, const END: usize>( self, value: [u32; M] ) -> Self

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

fn with_bits<const START: usize, const END: usize>( self, value: [u32; M] ) -> Self

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

fn with_bits<const START: usize, const END: usize>( self, value: [u32; M] ) -> Self

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

fn with_bits<const START: usize, const END: usize>( self, value: [u32; M] ) -> Self

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

fn with_bits<const START: usize, const END: usize>( self, value: [u32; M] ) -> Self

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

fn with_bits<const START: usize, const END: usize>( self, value: [u32; M] ) -> Self

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

fn with_bits<const START: usize, const END: usize>( self, value: [u32; M] ) -> Self

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

fn with_bits<const START: usize, const END: usize>( self, value: [u32; M] ) -> Self

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

fn with_bits<const START: usize, const END: usize>( self, value: [u32; M] ) -> Self

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

fn with_bits<const START: usize, const END: usize>( self, value: [u32; M] ) -> Self

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

fn with_bits<const START: usize, const END: usize>( self, value: [u32; M] ) -> Self

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

fn with_bits<const START: usize, const END: usize>( self, value: [u64; M] ) -> Self

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

fn with_bits<const START: usize, const END: usize>( self, value: [u64; M] ) -> Self

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

fn with_bits<const START: usize, const END: usize>( self, value: [u64; M] ) -> Self

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

fn with_bits<const START: usize, const END: usize>( self, value: [u64; M] ) -> Self

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

fn with_bits<const START: usize, const END: usize>( self, value: [u64; M] ) -> Self

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

fn with_bits<const START: usize, const END: usize>( self, value: [u64; M] ) -> Self

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

fn with_bits<const START: usize, const END: usize>( self, value: [u64; M] ) -> Self

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

fn with_bits<const START: usize, const END: usize>( self, value: [u64; M] ) -> Self

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

fn with_bits<const START: usize, const END: usize>( self, value: [u64; M] ) -> Self

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

fn with_bits<const START: usize, const END: usize>( self, value: [u64; M] ) -> Self

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

fn with_bits<const START: usize, const END: usize>( self, value: [u64; M] ) -> Self

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

fn with_bits<const START: usize, const END: usize>( self, value: [u64; M] ) -> Self

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

fn with_bits<const START: usize, const END: usize>( self, value: [u128; M] ) -> Self

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

fn with_bits<const START: usize, const END: usize>( self, value: [u128; M] ) -> Self

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

fn with_bits<const START: usize, const END: usize>( self, value: [u128; M] ) -> Self

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

fn with_bits<const START: usize, const END: usize>( self, value: [u128; M] ) -> Self

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

fn with_bits<const START: usize, const END: usize>( self, value: [u128; M] ) -> Self

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

fn with_bits<const START: usize, const END: usize>( self, value: [u128; M] ) -> Self

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

fn with_bits<const START: usize, const END: usize>( self, value: [u128; M] ) -> Self

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

fn with_bits<const START: usize, const END: usize>( self, value: [u128; M] ) -> Self

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

fn with_bits<const START: usize, const END: usize>( self, value: [u128; M] ) -> Self

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

fn with_bits<const START: usize, const END: usize>( self, value: [u128; M] ) -> Self

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

fn with_bits<const START: usize, const END: usize>( self, value: [u128; M] ) -> Self

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

fn with_bits<const START: usize, const END: usize>( self, value: [u128; M] ) -> Self

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

fn with_bits<const START: usize, const END: usize>( self, value: [usize; M] ) -> Self

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

fn with_bits<const START: usize, const END: usize>( self, value: [usize; M] ) -> Self

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

fn with_bits<const START: usize, const END: usize>( self, value: [usize; M] ) -> Self

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

fn with_bits<const START: usize, const END: usize>( self, value: [usize; M] ) -> Self

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

fn with_bits<const START: usize, const END: usize>( self, value: [usize; M] ) -> Self

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

fn with_bits<const START: usize, const END: usize>( self, value: [usize; M] ) -> Self

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

fn with_bits<const START: usize, const END: usize>( self, value: [usize; M] ) -> Self

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

fn with_bits<const START: usize, const END: usize>( self, value: [usize; M] ) -> Self

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

fn with_bits<const START: usize, const END: usize>( self, value: [usize; M] ) -> Self

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

fn with_bits<const START: usize, const END: usize>( self, value: [usize; M] ) -> Self

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

fn with_bits<const START: usize, const END: usize>( self, value: [usize; M] ) -> Self

impl<const M: usize> WithBits<[usize; M]> for usize

fn with_bits<const START: usize, const END: usize>( self, value: [usize; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[i8; M]> for [i8; N]

fn with_bits<const START: usize, const END: usize>(self, value: [i8; M]) -> Self

impl<const M: usize, const N: usize> WithBits<[i8; M]> for [i16; N]

fn with_bits<const START: usize, const END: usize>(self, value: [i8; M]) -> Self

impl<const M: usize, const N: usize> WithBits<[i8; M]> for [i32; N]

fn with_bits<const START: usize, const END: usize>(self, value: [i8; M]) -> Self

impl<const M: usize, const N: usize> WithBits<[i8; M]> for [i64; N]

fn with_bits<const START: usize, const END: usize>(self, value: [i8; M]) -> Self

impl<const M: usize, const N: usize> WithBits<[i8; M]> for [i128; N]

fn with_bits<const START: usize, const END: usize>(self, value: [i8; M]) -> Self

impl<const M: usize, const N: usize> WithBits<[i8; M]> for [isize; N]

fn with_bits<const START: usize, const END: usize>(self, value: [i8; M]) -> Self

impl<const M: usize, const N: usize> WithBits<[i8; M]> for [u8; N]

fn with_bits<const START: usize, const END: usize>(self, value: [i8; M]) -> Self

impl<const M: usize, const N: usize> WithBits<[i8; M]> for [u16; N]

fn with_bits<const START: usize, const END: usize>(self, value: [i8; M]) -> Self

impl<const M: usize, const N: usize> WithBits<[i8; M]> for [u32; N]

fn with_bits<const START: usize, const END: usize>(self, value: [i8; M]) -> Self

impl<const M: usize, const N: usize> WithBits<[i8; M]> for [u64; N]

fn with_bits<const START: usize, const END: usize>(self, value: [i8; M]) -> Self

impl<const M: usize, const N: usize> WithBits<[i8; M]> for [u128; N]

fn with_bits<const START: usize, const END: usize>(self, value: [i8; M]) -> Self

impl<const M: usize, const N: usize> WithBits<[i8; M]> for [usize; N]

fn with_bits<const START: usize, const END: usize>(self, value: [i8; M]) -> Self

impl<const M: usize, const N: usize> WithBits<[i16; M]> for [i8; N]

fn with_bits<const START: usize, const END: usize>( self, value: [i16; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[i16; M]> for [i16; N]

fn with_bits<const START: usize, const END: usize>( self, value: [i16; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[i16; M]> for [i32; N]

fn with_bits<const START: usize, const END: usize>( self, value: [i16; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[i16; M]> for [i64; N]

fn with_bits<const START: usize, const END: usize>( self, value: [i16; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[i16; M]> for [i128; N]

fn with_bits<const START: usize, const END: usize>( self, value: [i16; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[i16; M]> for [isize; N]

fn with_bits<const START: usize, const END: usize>( self, value: [i16; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[i16; M]> for [u8; N]

fn with_bits<const START: usize, const END: usize>( self, value: [i16; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[i16; M]> for [u16; N]

fn with_bits<const START: usize, const END: usize>( self, value: [i16; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[i16; M]> for [u32; N]

fn with_bits<const START: usize, const END: usize>( self, value: [i16; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[i16; M]> for [u64; N]

fn with_bits<const START: usize, const END: usize>( self, value: [i16; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[i16; M]> for [u128; N]

fn with_bits<const START: usize, const END: usize>( self, value: [i16; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[i16; M]> for [usize; N]

fn with_bits<const START: usize, const END: usize>( self, value: [i16; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[i32; M]> for [i8; N]

fn with_bits<const START: usize, const END: usize>( self, value: [i32; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[i32; M]> for [i16; N]

fn with_bits<const START: usize, const END: usize>( self, value: [i32; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[i32; M]> for [i32; N]

fn with_bits<const START: usize, const END: usize>( self, value: [i32; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[i32; M]> for [i64; N]

fn with_bits<const START: usize, const END: usize>( self, value: [i32; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[i32; M]> for [i128; N]

fn with_bits<const START: usize, const END: usize>( self, value: [i32; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[i32; M]> for [isize; N]

fn with_bits<const START: usize, const END: usize>( self, value: [i32; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[i32; M]> for [u8; N]

fn with_bits<const START: usize, const END: usize>( self, value: [i32; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[i32; M]> for [u16; N]

fn with_bits<const START: usize, const END: usize>( self, value: [i32; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[i32; M]> for [u32; N]

fn with_bits<const START: usize, const END: usize>( self, value: [i32; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[i32; M]> for [u64; N]

fn with_bits<const START: usize, const END: usize>( self, value: [i32; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[i32; M]> for [u128; N]

fn with_bits<const START: usize, const END: usize>( self, value: [i32; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[i32; M]> for [usize; N]

fn with_bits<const START: usize, const END: usize>( self, value: [i32; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[i64; M]> for [i8; N]

fn with_bits<const START: usize, const END: usize>( self, value: [i64; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[i64; M]> for [i16; N]

fn with_bits<const START: usize, const END: usize>( self, value: [i64; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[i64; M]> for [i32; N]

fn with_bits<const START: usize, const END: usize>( self, value: [i64; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[i64; M]> for [i64; N]

fn with_bits<const START: usize, const END: usize>( self, value: [i64; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[i64; M]> for [i128; N]

fn with_bits<const START: usize, const END: usize>( self, value: [i64; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[i64; M]> for [isize; N]

fn with_bits<const START: usize, const END: usize>( self, value: [i64; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[i64; M]> for [u8; N]

fn with_bits<const START: usize, const END: usize>( self, value: [i64; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[i64; M]> for [u16; N]

fn with_bits<const START: usize, const END: usize>( self, value: [i64; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[i64; M]> for [u32; N]

fn with_bits<const START: usize, const END: usize>( self, value: [i64; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[i64; M]> for [u64; N]

fn with_bits<const START: usize, const END: usize>( self, value: [i64; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[i64; M]> for [u128; N]

fn with_bits<const START: usize, const END: usize>( self, value: [i64; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[i64; M]> for [usize; N]

fn with_bits<const START: usize, const END: usize>( self, value: [i64; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[i128; M]> for [i8; N]

fn with_bits<const START: usize, const END: usize>( self, value: [i128; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[i128; M]> for [i16; N]

fn with_bits<const START: usize, const END: usize>( self, value: [i128; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[i128; M]> for [i32; N]

fn with_bits<const START: usize, const END: usize>( self, value: [i128; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[i128; M]> for [i64; N]

fn with_bits<const START: usize, const END: usize>( self, value: [i128; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[i128; M]> for [i128; N]

fn with_bits<const START: usize, const END: usize>( self, value: [i128; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[i128; M]> for [isize; N]

fn with_bits<const START: usize, const END: usize>( self, value: [i128; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[i128; M]> for [u8; N]

fn with_bits<const START: usize, const END: usize>( self, value: [i128; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[i128; M]> for [u16; N]

fn with_bits<const START: usize, const END: usize>( self, value: [i128; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[i128; M]> for [u32; N]

fn with_bits<const START: usize, const END: usize>( self, value: [i128; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[i128; M]> for [u64; N]

fn with_bits<const START: usize, const END: usize>( self, value: [i128; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[i128; M]> for [u128; N]

fn with_bits<const START: usize, const END: usize>( self, value: [i128; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[i128; M]> for [usize; N]

fn with_bits<const START: usize, const END: usize>( self, value: [i128; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[isize; M]> for [i8; N]

fn with_bits<const START: usize, const END: usize>( self, value: [isize; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[isize; M]> for [i16; N]

fn with_bits<const START: usize, const END: usize>( self, value: [isize; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[isize; M]> for [i32; N]

fn with_bits<const START: usize, const END: usize>( self, value: [isize; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[isize; M]> for [i64; N]

fn with_bits<const START: usize, const END: usize>( self, value: [isize; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[isize; M]> for [i128; N]

fn with_bits<const START: usize, const END: usize>( self, value: [isize; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[isize; M]> for [isize; N]

fn with_bits<const START: usize, const END: usize>( self, value: [isize; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[isize; M]> for [u8; N]

fn with_bits<const START: usize, const END: usize>( self, value: [isize; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[isize; M]> for [u16; N]

fn with_bits<const START: usize, const END: usize>( self, value: [isize; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[isize; M]> for [u32; N]

fn with_bits<const START: usize, const END: usize>( self, value: [isize; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[isize; M]> for [u64; N]

fn with_bits<const START: usize, const END: usize>( self, value: [isize; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[isize; M]> for [u128; N]

fn with_bits<const START: usize, const END: usize>( self, value: [isize; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[isize; M]> for [usize; N]

fn with_bits<const START: usize, const END: usize>( self, value: [isize; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[u8; M]> for [i8; N]

fn with_bits<const START: usize, const END: usize>(self, value: [u8; M]) -> Self

impl<const M: usize, const N: usize> WithBits<[u8; M]> for [i16; N]

fn with_bits<const START: usize, const END: usize>(self, value: [u8; M]) -> Self

impl<const M: usize, const N: usize> WithBits<[u8; M]> for [i32; N]

fn with_bits<const START: usize, const END: usize>(self, value: [u8; M]) -> Self

impl<const M: usize, const N: usize> WithBits<[u8; M]> for [i64; N]

fn with_bits<const START: usize, const END: usize>(self, value: [u8; M]) -> Self

impl<const M: usize, const N: usize> WithBits<[u8; M]> for [i128; N]

fn with_bits<const START: usize, const END: usize>(self, value: [u8; M]) -> Self

impl<const M: usize, const N: usize> WithBits<[u8; M]> for [isize; N]

fn with_bits<const START: usize, const END: usize>(self, value: [u8; M]) -> Self

impl<const M: usize, const N: usize> WithBits<[u8; M]> for [u8; N]

fn with_bits<const START: usize, const END: usize>(self, value: [u8; M]) -> Self

impl<const M: usize, const N: usize> WithBits<[u8; M]> for [u16; N]

fn with_bits<const START: usize, const END: usize>(self, value: [u8; M]) -> Self

impl<const M: usize, const N: usize> WithBits<[u8; M]> for [u32; N]

fn with_bits<const START: usize, const END: usize>(self, value: [u8; M]) -> Self

impl<const M: usize, const N: usize> WithBits<[u8; M]> for [u64; N]

fn with_bits<const START: usize, const END: usize>(self, value: [u8; M]) -> Self

impl<const M: usize, const N: usize> WithBits<[u8; M]> for [u128; N]

fn with_bits<const START: usize, const END: usize>(self, value: [u8; M]) -> Self

impl<const M: usize, const N: usize> WithBits<[u8; M]> for [usize; N]

fn with_bits<const START: usize, const END: usize>(self, value: [u8; M]) -> Self

impl<const M: usize, const N: usize> WithBits<[u16; M]> for [i8; N]

fn with_bits<const START: usize, const END: usize>( self, value: [u16; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[u16; M]> for [i16; N]

fn with_bits<const START: usize, const END: usize>( self, value: [u16; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[u16; M]> for [i32; N]

fn with_bits<const START: usize, const END: usize>( self, value: [u16; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[u16; M]> for [i64; N]

fn with_bits<const START: usize, const END: usize>( self, value: [u16; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[u16; M]> for [i128; N]

fn with_bits<const START: usize, const END: usize>( self, value: [u16; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[u16; M]> for [isize; N]

fn with_bits<const START: usize, const END: usize>( self, value: [u16; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[u16; M]> for [u8; N]

fn with_bits<const START: usize, const END: usize>( self, value: [u16; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[u16; M]> for [u16; N]

fn with_bits<const START: usize, const END: usize>( self, value: [u16; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[u16; M]> for [u32; N]

fn with_bits<const START: usize, const END: usize>( self, value: [u16; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[u16; M]> for [u64; N]

fn with_bits<const START: usize, const END: usize>( self, value: [u16; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[u16; M]> for [u128; N]

fn with_bits<const START: usize, const END: usize>( self, value: [u16; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[u16; M]> for [usize; N]

fn with_bits<const START: usize, const END: usize>( self, value: [u16; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[u32; M]> for [i8; N]

fn with_bits<const START: usize, const END: usize>( self, value: [u32; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[u32; M]> for [i16; N]

fn with_bits<const START: usize, const END: usize>( self, value: [u32; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[u32; M]> for [i32; N]

fn with_bits<const START: usize, const END: usize>( self, value: [u32; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[u32; M]> for [i64; N]

fn with_bits<const START: usize, const END: usize>( self, value: [u32; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[u32; M]> for [i128; N]

fn with_bits<const START: usize, const END: usize>( self, value: [u32; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[u32; M]> for [isize; N]

fn with_bits<const START: usize, const END: usize>( self, value: [u32; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[u32; M]> for [u8; N]

fn with_bits<const START: usize, const END: usize>( self, value: [u32; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[u32; M]> for [u16; N]

fn with_bits<const START: usize, const END: usize>( self, value: [u32; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[u32; M]> for [u32; N]

fn with_bits<const START: usize, const END: usize>( self, value: [u32; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[u32; M]> for [u64; N]

fn with_bits<const START: usize, const END: usize>( self, value: [u32; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[u32; M]> for [u128; N]

fn with_bits<const START: usize, const END: usize>( self, value: [u32; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[u32; M]> for [usize; N]

fn with_bits<const START: usize, const END: usize>( self, value: [u32; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[u64; M]> for [i8; N]

fn with_bits<const START: usize, const END: usize>( self, value: [u64; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[u64; M]> for [i16; N]

fn with_bits<const START: usize, const END: usize>( self, value: [u64; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[u64; M]> for [i32; N]

fn with_bits<const START: usize, const END: usize>( self, value: [u64; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[u64; M]> for [i64; N]

fn with_bits<const START: usize, const END: usize>( self, value: [u64; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[u64; M]> for [i128; N]

fn with_bits<const START: usize, const END: usize>( self, value: [u64; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[u64; M]> for [isize; N]

fn with_bits<const START: usize, const END: usize>( self, value: [u64; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[u64; M]> for [u8; N]

fn with_bits<const START: usize, const END: usize>( self, value: [u64; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[u64; M]> for [u16; N]

fn with_bits<const START: usize, const END: usize>( self, value: [u64; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[u64; M]> for [u32; N]

fn with_bits<const START: usize, const END: usize>( self, value: [u64; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[u64; M]> for [u64; N]

fn with_bits<const START: usize, const END: usize>( self, value: [u64; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[u64; M]> for [u128; N]

fn with_bits<const START: usize, const END: usize>( self, value: [u64; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[u64; M]> for [usize; N]

fn with_bits<const START: usize, const END: usize>( self, value: [u64; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[u128; M]> for [i8; N]

fn with_bits<const START: usize, const END: usize>( self, value: [u128; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[u128; M]> for [i16; N]

fn with_bits<const START: usize, const END: usize>( self, value: [u128; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[u128; M]> for [i32; N]

fn with_bits<const START: usize, const END: usize>( self, value: [u128; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[u128; M]> for [i64; N]

fn with_bits<const START: usize, const END: usize>( self, value: [u128; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[u128; M]> for [i128; N]

fn with_bits<const START: usize, const END: usize>( self, value: [u128; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[u128; M]> for [isize; N]

fn with_bits<const START: usize, const END: usize>( self, value: [u128; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[u128; M]> for [u8; N]

fn with_bits<const START: usize, const END: usize>( self, value: [u128; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[u128; M]> for [u16; N]

fn with_bits<const START: usize, const END: usize>( self, value: [u128; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[u128; M]> for [u32; N]

fn with_bits<const START: usize, const END: usize>( self, value: [u128; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[u128; M]> for [u64; N]

fn with_bits<const START: usize, const END: usize>( self, value: [u128; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[u128; M]> for [u128; N]

fn with_bits<const START: usize, const END: usize>( self, value: [u128; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[u128; M]> for [usize; N]

fn with_bits<const START: usize, const END: usize>( self, value: [u128; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[usize; M]> for [i8; N]

fn with_bits<const START: usize, const END: usize>( self, value: [usize; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[usize; M]> for [i16; N]

fn with_bits<const START: usize, const END: usize>( self, value: [usize; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[usize; M]> for [i32; N]

fn with_bits<const START: usize, const END: usize>( self, value: [usize; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[usize; M]> for [i64; N]

fn with_bits<const START: usize, const END: usize>( self, value: [usize; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[usize; M]> for [i128; N]

fn with_bits<const START: usize, const END: usize>( self, value: [usize; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[usize; M]> for [isize; N]

fn with_bits<const START: usize, const END: usize>( self, value: [usize; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[usize; M]> for [u8; N]

fn with_bits<const START: usize, const END: usize>( self, value: [usize; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[usize; M]> for [u16; N]

fn with_bits<const START: usize, const END: usize>( self, value: [usize; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[usize; M]> for [u32; N]

fn with_bits<const START: usize, const END: usize>( self, value: [usize; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[usize; M]> for [u64; N]

fn with_bits<const START: usize, const END: usize>( self, value: [usize; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[usize; M]> for [u128; N]

fn with_bits<const START: usize, const END: usize>( self, value: [usize; M] ) -> Self

impl<const M: usize, const N: usize> WithBits<[usize; M]> for [usize; N]

fn with_bits<const START: usize, const END: usize>( self, value: [usize; M] ) -> Self

impl<const N: usize> WithBits<i8> for [i8; N]

fn with_bits<const START: usize, const END: usize>(self, value: i8) -> Self

impl<const N: usize> WithBits<i8> for [i16; N]

fn with_bits<const START: usize, const END: usize>(self, value: i8) -> Self

impl<const N: usize> WithBits<i8> for [i32; N]

fn with_bits<const START: usize, const END: usize>(self, value: i8) -> Self

impl<const N: usize> WithBits<i8> for [i64; N]

fn with_bits<const START: usize, const END: usize>(self, value: i8) -> Self

impl<const N: usize> WithBits<i8> for [i128; N]

fn with_bits<const START: usize, const END: usize>(self, value: i8) -> Self

impl<const N: usize> WithBits<i8> for [isize; N]

fn with_bits<const START: usize, const END: usize>(self, value: i8) -> Self

impl<const N: usize> WithBits<i8> for [u8; N]

fn with_bits<const START: usize, const END: usize>(self, value: i8) -> Self

impl<const N: usize> WithBits<i8> for [u16; N]

fn with_bits<const START: usize, const END: usize>(self, value: i8) -> Self

impl<const N: usize> WithBits<i8> for [u32; N]

fn with_bits<const START: usize, const END: usize>(self, value: i8) -> Self

impl<const N: usize> WithBits<i8> for [u64; N]

fn with_bits<const START: usize, const END: usize>(self, value: i8) -> Self

impl<const N: usize> WithBits<i8> for [u128; N]

fn with_bits<const START: usize, const END: usize>(self, value: i8) -> Self

impl<const N: usize> WithBits<i8> for [usize; N]

fn with_bits<const START: usize, const END: usize>(self, value: i8) -> Self

impl<const N: usize> WithBits<i16> for [i8; N]

fn with_bits<const START: usize, const END: usize>(self, value: i16) -> Self

impl<const N: usize> WithBits<i16> for [i16; N]

fn with_bits<const START: usize, const END: usize>(self, value: i16) -> Self

impl<const N: usize> WithBits<i16> for [i32; N]

fn with_bits<const START: usize, const END: usize>(self, value: i16) -> Self

impl<const N: usize> WithBits<i16> for [i64; N]

fn with_bits<const START: usize, const END: usize>(self, value: i16) -> Self

impl<const N: usize> WithBits<i16> for [i128; N]

fn with_bits<const START: usize, const END: usize>(self, value: i16) -> Self

impl<const N: usize> WithBits<i16> for [isize; N]

fn with_bits<const START: usize, const END: usize>(self, value: i16) -> Self

impl<const N: usize> WithBits<i16> for [u8; N]

fn with_bits<const START: usize, const END: usize>(self, value: i16) -> Self

impl<const N: usize> WithBits<i16> for [u16; N]

fn with_bits<const START: usize, const END: usize>(self, value: i16) -> Self

impl<const N: usize> WithBits<i16> for [u32; N]

fn with_bits<const START: usize, const END: usize>(self, value: i16) -> Self

impl<const N: usize> WithBits<i16> for [u64; N]

fn with_bits<const START: usize, const END: usize>(self, value: i16) -> Self

impl<const N: usize> WithBits<i16> for [u128; N]

fn with_bits<const START: usize, const END: usize>(self, value: i16) -> Self

impl<const N: usize> WithBits<i16> for [usize; N]

fn with_bits<const START: usize, const END: usize>(self, value: i16) -> Self

impl<const N: usize> WithBits<i32> for [i8; N]

fn with_bits<const START: usize, const END: usize>(self, value: i32) -> Self

impl<const N: usize> WithBits<i32> for [i16; N]

fn with_bits<const START: usize, const END: usize>(self, value: i32) -> Self

impl<const N: usize> WithBits<i32> for [i32; N]

fn with_bits<const START: usize, const END: usize>(self, value: i32) -> Self

impl<const N: usize> WithBits<i32> for [i64; N]

fn with_bits<const START: usize, const END: usize>(self, value: i32) -> Self

impl<const N: usize> WithBits<i32> for [i128; N]

fn with_bits<const START: usize, const END: usize>(self, value: i32) -> Self

impl<const N: usize> WithBits<i32> for [isize; N]

fn with_bits<const START: usize, const END: usize>(self, value: i32) -> Self

impl<const N: usize> WithBits<i32> for [u8; N]

fn with_bits<const START: usize, const END: usize>(self, value: i32) -> Self

impl<const N: usize> WithBits<i32> for [u16; N]

fn with_bits<const START: usize, const END: usize>(self, value: i32) -> Self

impl<const N: usize> WithBits<i32> for [u32; N]

fn with_bits<const START: usize, const END: usize>(self, value: i32) -> Self

impl<const N: usize> WithBits<i32> for [u64; N]

fn with_bits<const START: usize, const END: usize>(self, value: i32) -> Self

impl<const N: usize> WithBits<i32> for [u128; N]

fn with_bits<const START: usize, const END: usize>(self, value: i32) -> Self

impl<const N: usize> WithBits<i32> for [usize; N]

fn with_bits<const START: usize, const END: usize>(self, value: i32) -> Self

impl<const N: usize> WithBits<i64> for [i8; N]

fn with_bits<const START: usize, const END: usize>(self, value: i64) -> Self

impl<const N: usize> WithBits<i64> for [i16; N]

fn with_bits<const START: usize, const END: usize>(self, value: i64) -> Self

impl<const N: usize> WithBits<i64> for [i32; N]

fn with_bits<const START: usize, const END: usize>(self, value: i64) -> Self

impl<const N: usize> WithBits<i64> for [i64; N]

fn with_bits<const START: usize, const END: usize>(self, value: i64) -> Self

impl<const N: usize> WithBits<i64> for [i128; N]

fn with_bits<const START: usize, const END: usize>(self, value: i64) -> Self

impl<const N: usize> WithBits<i64> for [isize; N]

fn with_bits<const START: usize, const END: usize>(self, value: i64) -> Self

impl<const N: usize> WithBits<i64> for [u8; N]

fn with_bits<const START: usize, const END: usize>(self, value: i64) -> Self

impl<const N: usize> WithBits<i64> for [u16; N]

fn with_bits<const START: usize, const END: usize>(self, value: i64) -> Self

impl<const N: usize> WithBits<i64> for [u32; N]

fn with_bits<const START: usize, const END: usize>(self, value: i64) -> Self

impl<const N: usize> WithBits<i64> for [u64; N]

fn with_bits<const START: usize, const END: usize>(self, value: i64) -> Self

impl<const N: usize> WithBits<i64> for [u128; N]

fn with_bits<const START: usize, const END: usize>(self, value: i64) -> Self

impl<const N: usize> WithBits<i64> for [usize; N]

fn with_bits<const START: usize, const END: usize>(self, value: i64) -> Self

impl<const N: usize> WithBits<i128> for [i8; N]

fn with_bits<const START: usize, const END: usize>(self, value: i128) -> Self

impl<const N: usize> WithBits<i128> for [i16; N]

fn with_bits<const START: usize, const END: usize>(self, value: i128) -> Self

impl<const N: usize> WithBits<i128> for [i32; N]

fn with_bits<const START: usize, const END: usize>(self, value: i128) -> Self

impl<const N: usize> WithBits<i128> for [i64; N]

fn with_bits<const START: usize, const END: usize>(self, value: i128) -> Self

impl<const N: usize> WithBits<i128> for [i128; N]

fn with_bits<const START: usize, const END: usize>(self, value: i128) -> Self

impl<const N: usize> WithBits<i128> for [isize; N]

fn with_bits<const START: usize, const END: usize>(self, value: i128) -> Self

impl<const N: usize> WithBits<i128> for [u8; N]

fn with_bits<const START: usize, const END: usize>(self, value: i128) -> Self

impl<const N: usize> WithBits<i128> for [u16; N]

fn with_bits<const START: usize, const END: usize>(self, value: i128) -> Self

impl<const N: usize> WithBits<i128> for [u32; N]

fn with_bits<const START: usize, const END: usize>(self, value: i128) -> Self

impl<const N: usize> WithBits<i128> for [u64; N]

fn with_bits<const START: usize, const END: usize>(self, value: i128) -> Self

impl<const N: usize> WithBits<i128> for [u128; N]

fn with_bits<const START: usize, const END: usize>(self, value: i128) -> Self

impl<const N: usize> WithBits<i128> for [usize; N]

fn with_bits<const START: usize, const END: usize>(self, value: i128) -> Self

impl<const N: usize> WithBits<isize> for [i8; N]

fn with_bits<const START: usize, const END: usize>(self, value: isize) -> Self

impl<const N: usize> WithBits<isize> for [i16; N]

fn with_bits<const START: usize, const END: usize>(self, value: isize) -> Self

impl<const N: usize> WithBits<isize> for [i32; N]

fn with_bits<const START: usize, const END: usize>(self, value: isize) -> Self

impl<const N: usize> WithBits<isize> for [i64; N]

fn with_bits<const START: usize, const END: usize>(self, value: isize) -> Self

impl<const N: usize> WithBits<isize> for [i128; N]

fn with_bits<const START: usize, const END: usize>(self, value: isize) -> Self

impl<const N: usize> WithBits<isize> for [isize; N]

fn with_bits<const START: usize, const END: usize>(self, value: isize) -> Self

impl<const N: usize> WithBits<isize> for [u8; N]

fn with_bits<const START: usize, const END: usize>(self, value: isize) -> Self

impl<const N: usize> WithBits<isize> for [u16; N]

fn with_bits<const START: usize, const END: usize>(self, value: isize) -> Self

impl<const N: usize> WithBits<isize> for [u32; N]

fn with_bits<const START: usize, const END: usize>(self, value: isize) -> Self

impl<const N: usize> WithBits<isize> for [u64; N]

fn with_bits<const START: usize, const END: usize>(self, value: isize) -> Self

impl<const N: usize> WithBits<isize> for [u128; N]

fn with_bits<const START: usize, const END: usize>(self, value: isize) -> Self

impl<const N: usize> WithBits<isize> for [usize; N]

fn with_bits<const START: usize, const END: usize>(self, value: isize) -> Self

impl<const N: usize> WithBits<u8> for [i8; N]

fn with_bits<const START: usize, const END: usize>(self, value: u8) -> Self

impl<const N: usize> WithBits<u8> for [i16; N]

fn with_bits<const START: usize, const END: usize>(self, value: u8) -> Self

impl<const N: usize> WithBits<u8> for [i32; N]

fn with_bits<const START: usize, const END: usize>(self, value: u8) -> Self

impl<const N: usize> WithBits<u8> for [i64; N]

fn with_bits<const START: usize, const END: usize>(self, value: u8) -> Self

impl<const N: usize> WithBits<u8> for [i128; N]

fn with_bits<const START: usize, const END: usize>(self, value: u8) -> Self

impl<const N: usize> WithBits<u8> for [isize; N]

fn with_bits<const START: usize, const END: usize>(self, value: u8) -> Self

impl<const N: usize> WithBits<u8> for [u8; N]

fn with_bits<const START: usize, const END: usize>(self, value: u8) -> Self

impl<const N: usize> WithBits<u8> for [u16; N]

fn with_bits<const START: usize, const END: usize>(self, value: u8) -> Self

impl<const N: usize> WithBits<u8> for [u32; N]

fn with_bits<const START: usize, const END: usize>(self, value: u8) -> Self

impl<const N: usize> WithBits<u8> for [u64; N]

fn with_bits<const START: usize, const END: usize>(self, value: u8) -> Self

impl<const N: usize> WithBits<u8> for [u128; N]

fn with_bits<const START: usize, const END: usize>(self, value: u8) -> Self

impl<const N: usize> WithBits<u8> for [usize; N]

fn with_bits<const START: usize, const END: usize>(self, value: u8) -> Self

impl<const N: usize> WithBits<u16> for [i8; N]

fn with_bits<const START: usize, const END: usize>(self, value: u16) -> Self

impl<const N: usize> WithBits<u16> for [i16; N]

fn with_bits<const START: usize, const END: usize>(self, value: u16) -> Self

impl<const N: usize> WithBits<u16> for [i32; N]

fn with_bits<const START: usize, const END: usize>(self, value: u16) -> Self

impl<const N: usize> WithBits<u16> for [i64; N]

fn with_bits<const START: usize, const END: usize>(self, value: u16) -> Self

impl<const N: usize> WithBits<u16> for [i128; N]

fn with_bits<const START: usize, const END: usize>(self, value: u16) -> Self

impl<const N: usize> WithBits<u16> for [isize; N]

fn with_bits<const START: usize, const END: usize>(self, value: u16) -> Self

impl<const N: usize> WithBits<u16> for [u8; N]

fn with_bits<const START: usize, const END: usize>(self, value: u16) -> Self

impl<const N: usize> WithBits<u16> for [u16; N]

fn with_bits<const START: usize, const END: usize>(self, value: u16) -> Self

impl<const N: usize> WithBits<u16> for [u32; N]

fn with_bits<const START: usize, const END: usize>(self, value: u16) -> Self

impl<const N: usize> WithBits<u16> for [u64; N]

fn with_bits<const START: usize, const END: usize>(self, value: u16) -> Self

impl<const N: usize> WithBits<u16> for [u128; N]

fn with_bits<const START: usize, const END: usize>(self, value: u16) -> Self

impl<const N: usize> WithBits<u16> for [usize; N]

fn with_bits<const START: usize, const END: usize>(self, value: u16) -> Self

impl<const N: usize> WithBits<u32> for [i8; N]

fn with_bits<const START: usize, const END: usize>(self, value: u32) -> Self

impl<const N: usize> WithBits<u32> for [i16; N]

fn with_bits<const START: usize, const END: usize>(self, value: u32) -> Self

impl<const N: usize> WithBits<u32> for [i32; N]

fn with_bits<const START: usize, const END: usize>(self, value: u32) -> Self

impl<const N: usize> WithBits<u32> for [i64; N]

fn with_bits<const START: usize, const END: usize>(self, value: u32) -> Self

impl<const N: usize> WithBits<u32> for [i128; N]

fn with_bits<const START: usize, const END: usize>(self, value: u32) -> Self

impl<const N: usize> WithBits<u32> for [isize; N]

fn with_bits<const START: usize, const END: usize>(self, value: u32) -> Self

impl<const N: usize> WithBits<u32> for [u8; N]

fn with_bits<const START: usize, const END: usize>(self, value: u32) -> Self

impl<const N: usize> WithBits<u32> for [u16; N]

fn with_bits<const START: usize, const END: usize>(self, value: u32) -> Self

impl<const N: usize> WithBits<u32> for [u32; N]

fn with_bits<const START: usize, const END: usize>(self, value: u32) -> Self

impl<const N: usize> WithBits<u32> for [u64; N]

fn with_bits<const START: usize, const END: usize>(self, value: u32) -> Self

impl<const N: usize> WithBits<u32> for [u128; N]

fn with_bits<const START: usize, const END: usize>(self, value: u32) -> Self

impl<const N: usize> WithBits<u32> for [usize; N]

fn with_bits<const START: usize, const END: usize>(self, value: u32) -> Self

impl<const N: usize> WithBits<u64> for [i8; N]

fn with_bits<const START: usize, const END: usize>(self, value: u64) -> Self

impl<const N: usize> WithBits<u64> for [i16; N]

fn with_bits<const START: usize, const END: usize>(self, value: u64) -> Self

impl<const N: usize> WithBits<u64> for [i32; N]

fn with_bits<const START: usize, const END: usize>(self, value: u64) -> Self

impl<const N: usize> WithBits<u64> for [i64; N]

fn with_bits<const START: usize, const END: usize>(self, value: u64) -> Self

impl<const N: usize> WithBits<u64> for [i128; N]

fn with_bits<const START: usize, const END: usize>(self, value: u64) -> Self

impl<const N: usize> WithBits<u64> for [isize; N]

fn with_bits<const START: usize, const END: usize>(self, value: u64) -> Self

impl<const N: usize> WithBits<u64> for [u8; N]

fn with_bits<const START: usize, const END: usize>(self, value: u64) -> Self

impl<const N: usize> WithBits<u64> for [u16; N]

fn with_bits<const START: usize, const END: usize>(self, value: u64) -> Self

impl<const N: usize> WithBits<u64> for [u32; N]

fn with_bits<const START: usize, const END: usize>(self, value: u64) -> Self

impl<const N: usize> WithBits<u64> for [u64; N]

fn with_bits<const START: usize, const END: usize>(self, value: u64) -> Self

impl<const N: usize> WithBits<u64> for [u128; N]

fn with_bits<const START: usize, const END: usize>(self, value: u64) -> Self

impl<const N: usize> WithBits<u64> for [usize; N]

fn with_bits<const START: usize, const END: usize>(self, value: u64) -> Self

impl<const N: usize> WithBits<u128> for [i8; N]

fn with_bits<const START: usize, const END: usize>(self, value: u128) -> Self

impl<const N: usize> WithBits<u128> for [i16; N]

fn with_bits<const START: usize, const END: usize>(self, value: u128) -> Self

impl<const N: usize> WithBits<u128> for [i32; N]

fn with_bits<const START: usize, const END: usize>(self, value: u128) -> Self

impl<const N: usize> WithBits<u128> for [i64; N]

fn with_bits<const START: usize, const END: usize>(self, value: u128) -> Self

impl<const N: usize> WithBits<u128> for [i128; N]

fn with_bits<const START: usize, const END: usize>(self, value: u128) -> Self

impl<const N: usize> WithBits<u128> for [isize; N]

fn with_bits<const START: usize, const END: usize>(self, value: u128) -> Self

impl<const N: usize> WithBits<u128> for [u8; N]

fn with_bits<const START: usize, const END: usize>(self, value: u128) -> Self

impl<const N: usize> WithBits<u128> for [u16; N]

fn with_bits<const START: usize, const END: usize>(self, value: u128) -> Self

impl<const N: usize> WithBits<u128> for [u32; N]

fn with_bits<const START: usize, const END: usize>(self, value: u128) -> Self

impl<const N: usize> WithBits<u128> for [u64; N]

fn with_bits<const START: usize, const END: usize>(self, value: u128) -> Self

impl<const N: usize> WithBits<u128> for [u128; N]

fn with_bits<const START: usize, const END: usize>(self, value: u128) -> Self

impl<const N: usize> WithBits<u128> for [usize; N]

fn with_bits<const START: usize, const END: usize>(self, value: u128) -> Self

impl<const N: usize> WithBits<usize> for [i8; N]

fn with_bits<const START: usize, const END: usize>(self, value: usize) -> Self

impl<const N: usize> WithBits<usize> for [i16; N]

fn with_bits<const START: usize, const END: usize>(self, value: usize) -> Self

impl<const N: usize> WithBits<usize> for [i32; N]

fn with_bits<const START: usize, const END: usize>(self, value: usize) -> Self

impl<const N: usize> WithBits<usize> for [i64; N]

fn with_bits<const START: usize, const END: usize>(self, value: usize) -> Self

impl<const N: usize> WithBits<usize> for [i128; N]

fn with_bits<const START: usize, const END: usize>(self, value: usize) -> Self

impl<const N: usize> WithBits<usize> for [isize; N]

fn with_bits<const START: usize, const END: usize>(self, value: usize) -> Self

impl<const N: usize> WithBits<usize> for [u8; N]

fn with_bits<const START: usize, const END: usize>(self, value: usize) -> Self

impl<const N: usize> WithBits<usize> for [u16; N]

fn with_bits<const START: usize, const END: usize>(self, value: usize) -> Self

impl<const N: usize> WithBits<usize> for [u32; N]

fn with_bits<const START: usize, const END: usize>(self, value: usize) -> Self

impl<const N: usize> WithBits<usize> for [u64; N]

fn with_bits<const START: usize, const END: usize>(self, value: usize) -> Self

impl<const N: usize> WithBits<usize> for [u128; N]

fn with_bits<const START: usize, const END: usize>(self, value: usize) -> Self

impl<const N: usize> WithBits<usize> for [usize; N]

fn with_bits<const START: usize, const END: usize>(self, value: usize) -> Self

Implementors