Enum snarkvm_circuit::Literal

pub enum Literal<A>where
    A: Aleo,{
    Address(Address<A>),
    Boolean(Boolean<A>),
    Field(Field<A>),
    Group(Group<A>),
    I8(Integer<A, i8>),
    I16(Integer<A, i16>),
    I32(Integer<A, i32>),
    I64(Integer<A, i64>),
    I128(Integer<A, i128>),
    U8(Integer<A, u8>),
    U16(Integer<A, u16>),
    U32(Integer<A, u32>),
    U64(Integer<A, u64>),
    U128(Integer<A, u128>),
    Scalar(Scalar<A>),
    String(StringType<A>),
}

The literal enum represents all supported circuit types in snarkVM.

Variants

Address(Address<A>)

The Aleo address type.

Boolean(Boolean<A>)

The boolean type.

Field(Field<A>)

The field type (base field).

Group(Group<A>)

The group type (affine).

I8(Integer<A, i8>)

The 8-bit signed integer type.

I16(Integer<A, i16>)

The 16-bit signed integer type.

I32(Integer<A, i32>)

The 32-bit signed integer type.

I64(Integer<A, i64>)

The 64-bit signed integer type.

I128(Integer<A, i128>)

The 128-bit signed integer type.

U8(Integer<A, u8>)

The 8-bit unsigned integer type.

U16(Integer<A, u16>)

The 16-bit unsigned integer type.

U32(Integer<A, u32>)

The 32-bit unsigned integer type.

U64(Integer<A, u64>)

The 64-bit unsigned integer type.

U128(Integer<A, u128>)

The 128-bit unsigned integer type.

Scalar(Scalar<A>)

The scalar type (scalar field).

String(StringType<A>)

The string type.

Implementations

impl<A> Literal<A>where A: Aleo,

pub fn downcast(&self, to_type: LiteralType) -> Result<Literal<A>, Error>

Downcasts the literal to the given literal type.

This method checks that the downcast does not lose any bits of information, and returns an error if it does.

The hierarchy of downcasting is as follows:

• (Address, Group) -> Field -> Scalar -> Integer -> Boolean
• String (not supported)

pub fn downcast_lossy(&self, to_type: LiteralType) -> Result<Literal<A>, Error>

Downcasts the literal to the given literal type, with lossy truncation.

This method makes a best-effort attempt to preserve upcasting back to the original literal type, but it is not guaranteed to do so.

The hierarchy of downcasting is as follows:

• (Address, Group) -> Field -> Scalar -> Integer -> Boolean
• String (not supported)

impl<A> Literal<A>where A: Aleo,

pub fn from_bits_le( variant: &Integer<A, u8>, bits_le: &[Boolean<A>] ) -> Literal<A>

Initializes a new literal from a list of little-endian bits without trailing zeros.

pub fn from_bits_be( variant: &Integer<A, u8>, bits_be: &[Boolean<A>] ) -> Literal<A>

Initializes a new literal from a list of big-endian bits without leading zeros.

impl<A> Literal<A>where A: Aleo,

pub fn size_in_bits(&self) -> Integer<A, u16>

Returns the number of bits of this literal.

impl<A> Literal<A>where A: Aleo,

pub fn to_type(&self) -> LiteralType

Returns the type name of the literal.

impl<A> Literal<A>where A: Aleo,

pub fn variant(&self) -> Integer<A, u8>

Returns the variant of the literal.

impl<A> Literal<A>where A: Aleo,

pub fn type_name(&self) -> &str

Returns the type name of the literal.

Trait Implementations

impl<A> Clone for Literal<A>where A: Clone + Aleo,

fn clone(&self) -> Literal<A>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<A> Debug for Literal<A>where A: Aleo,

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

Formats the value using the given formatter.

impl<A> Display for Literal<A>where A: Aleo,

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

Formats the value using the given formatter.

impl<A> Eject for Literal<A>where A: Aleo,

fn eject_mode(&self) -> Mode

Ejects the mode of the literal.

fn eject_value(&self) -> <Literal<A> as Eject>::Primitive

Ejects the literal into its primitive.

type Primitive = Literal<<A as Environment>::Network>

fn eject(&self) -> (Mode, Self::Primitive)

Ejects the mode and primitive value of the circuit type.

fn is_constant(&self) -> bool

Returns true if the circuit is a constant.

fn is_public(&self) -> bool

Returns true if the circuit is a public.

fn is_private(&self) -> bool

Returns true if the circuit is a private.

impl<A> Equal<Literal<A>> for Literal<A>where A: Aleo,

fn is_equal( &self, other: &Literal<A> ) -> <Literal<A> as Equal<Literal<A>>>::Output

Returns true if self and other are equal.

fn is_not_equal( &self, other: &Literal<A> ) -> <Literal<A> as Equal<Literal<A>>>::Output

Returns true if self and other are not equal.

type Output = Boolean<A>

impl<A> From<&Literal<A>> for Plaintext<A>where A: Aleo,

fn from(literal: &Literal<A>) -> Plaintext<A>

Returns a new Plaintext from a Literal.

impl<A> From<Literal<A>> for Plaintext<A>where A: Aleo,

fn from(literal: Literal<A>) -> Plaintext<A>

Returns a new Plaintext from a Literal.

impl<A> FromStr for Literal<A>where A: Aleo,

fn from_str(string: &str) -> Result<Literal<A>, Error>

Parses a string into a literal circuit.

type Err = Error

The associated error which can be returned from parsing.

impl<A> Inject for Literal<A>where A: Aleo,

fn new(mode: Mode, value: <Literal<A> as Inject>::Primitive) -> Literal<A>

Initializes a new literal from a primitive.

type Primitive = Literal<<A as Environment>::Network>

fn constant(value: Self::Primitive) -> Selfwhere Self: Sized,

Initializes a constant of the given primitive value.

impl<A> Parser for Literal<A>where A: Aleo,

fn parse(string: &str) -> Result<(&str, Literal<A>), Err<VerboseError<&str>>>

Parses a string into a literal.

impl<A> ToBits for &Literal<A>where A: Aleo,

fn to_bits_le(&self) -> Vec<Boolean<A>, Global>

Returns the little-endian bits of the literal.

fn to_bits_be(&self) -> Vec<Boolean<A>, Global>

Returns the big-endian bits of the literal.

type Boolean = Boolean<A>

impl<A> ToBits for Literal<A>where A: Aleo,

fn to_bits_le(&self) -> Vec<Boolean<A>, Global>

Returns the little-endian bits of the literal.

fn to_bits_be(&self) -> Vec<Boolean<A>, Global>

Returns the big-endian bits of the literal.

type Boolean = Boolean<A>

impl<A> ToFields for &Literal<A>where A: Aleo,

fn to_fields(&self) -> Vec<<&Literal<A> as ToFields>::Field, Global>

Returns the literal as a list of base field elements.

type Field = Field<A>

impl<A> ToFields for Literal<A>where A: Aleo,

fn to_fields(&self) -> Vec<Field<A>, Global>

Returns the literal as a list of base field elements.

type Field = Field<A>