Trait Bitsized 

pub trait Bitsized {
    type ArbitraryInt;

    const BITS: usize;
    const MAX: Self::ArbitraryInt;
}

This is internally used, but might be useful. No guarantees are given (for now).

Required Associated Constants

const BITS: usize

const MAX: Self::ArbitraryInt

Required Associated Types

type ArbitraryInt

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 Bitsized for bool

Handle bool as a u1

const BITS: usize = 1usize

const MAX: Self::ArbitraryInt = {transmute(0x01): <bool as Bitsized>::ArbitraryInt}

type ArbitraryInt = UInt<u8, 1>

impl Bitsized for i8

const BITS: usize = 8usize

const MAX: Self::ArbitraryInt = {transmute(0x7f): <i8 as Bitsized>::ArbitraryInt}

type ArbitraryInt = i8

impl Bitsized for i16

const BITS: usize = 16usize

const MAX: Self::ArbitraryInt = {transmute(0x7fff): <i16 as Bitsized>::ArbitraryInt}

type ArbitraryInt = i16

impl Bitsized for i32

const BITS: usize = 32usize

const MAX: Self::ArbitraryInt = {transmute(0x7fffffff): <i32 as Bitsized>::ArbitraryInt}

type ArbitraryInt = i32

impl Bitsized for i64

const BITS: usize = 64usize

const MAX: Self::ArbitraryInt = {transmute(0x7fffffffffffffff): <i64 as Bitsized>::ArbitraryInt}

type ArbitraryInt = i64

impl Bitsized for i128

const BITS: usize = 128usize

const MAX: Self::ArbitraryInt = {transmute(0x7fffffffffffffffffffffffffffffff): <i128 as Bitsized>::ArbitraryInt}

type ArbitraryInt = i128

impl Bitsized for u8

const BITS: usize = 8usize

const MAX: Self::ArbitraryInt = {transmute(0xff): <u8 as Bitsized>::ArbitraryInt}

type ArbitraryInt = u8

impl Bitsized for u16

const BITS: usize = 16usize

const MAX: Self::ArbitraryInt = {transmute(0xffff): <u16 as Bitsized>::ArbitraryInt}

type ArbitraryInt = u16

impl Bitsized for u32

const BITS: usize = 32usize

const MAX: Self::ArbitraryInt = {transmute(0xffffffff): <u32 as Bitsized>::ArbitraryInt}

type ArbitraryInt = u32

impl Bitsized for u64

const BITS: usize = 64usize

const MAX: Self::ArbitraryInt = {transmute(0xffffffffffffffff): <u64 as Bitsized>::ArbitraryInt}

type ArbitraryInt = u64

impl Bitsized for u128

const BITS: usize = 128usize

const MAX: Self::ArbitraryInt = {transmute(0xffffffffffffffffffffffffffffffff): <u128 as Bitsized>::ArbitraryInt}

type ArbitraryInt = u128

impl<BaseType, const BITS: usize> Bitsized for Int<BaseType, BITS>

where BaseType: SignedInteger + BuiltinInteger, Int<BaseType, BITS>: SignedInteger,

const BITS: usize = BITS

const MAX: Self::ArbitraryInt = <Self as arbitrary_int::traits::Integer>::MAX

type ArbitraryInt = Int<BaseType, BITS>

impl<BaseType, const BITS: usize> Bitsized for UInt<BaseType, BITS>

where BaseType: UnsignedInteger + BuiltinInteger, UInt<BaseType, BITS>: UnsignedInteger,

Only basing this on Integer did not work, as bool and others are not Integer. We could remove the whole macro_rules thing if it worked, though. Maybe there is some way to do this, I’m not deep into types. Finding some way to combine Integer and Bitsized would be good as well.

const BITS: usize = BITS

const MAX: Self::ArbitraryInt = <Self as arbitrary_int::traits::Integer>::MAX

type ArbitraryInt = UInt<BaseType, BITS>

Implementors