Enum ComparableConstantValue 

pub enum ComparableConstantValue<'a> {
    None,
    Boolean(bool),
    Str(&'a str),
    Bytes(Cow<'a, [u8]>),
    Integer(&'a str),
    Tuple(Vec<ComparableConstantValue<'a>>),
    Frozenset(Vec<ComparableConstantValue<'a>>),
    Float(u64),
    Complex {
        real: u64,
        imag: u64,
    },
    Ellipsis,
}

Variants

None

Boolean(bool)

Str(&'a str)

Bytes(Cow<'a, [u8]>)

Integer(&'a str)

Tuple(Vec<ComparableConstantValue<'a>>)

Frozenset(Vec<ComparableConstantValue<'a>>)

Float(u64)

Complex

Fields

real: u64

imag: u64

Ellipsis

Trait Implementations

impl<'a> Debug for ComparableConstantValue<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<'a> Eq for ComparableConstantValue<'a>

impl<'a> From<&'a ConstantValue> for ComparableConstantValue<'a>

fn from(value: &'a ConstantValue) -> ComparableConstantValue<'a>

Converts to this type from the input type.

impl<'a> Hash for ComparableConstantValue<'a>

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<'a> PartialEq for ComparableConstantValue<'a>

fn eq(&self, other: &ComparableConstantValue<'a>) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl<'a> StructuralPartialEq for ComparableConstantValue<'a>