Enum Literal

pub enum Literal<A: Aleo> {
    Address(Address<A>),
    Boolean(Boolean<A>),
    Field(Field<A>),
    Group(Group<A>),
    I8(I8<A>),
    I16(I16<A>),
    I32(I32<A>),
    I64(I64<A>),
    I128(I128<A>),
    U8(U8<A>),
    U16(U16<A>),
    U32(U32<A>),
    U64(U64<A>),
    U128(U128<A>),
    Scalar(Scalar<A>),
    Signature(Box<Signature<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(I8<A>)

The 8-bit signed integer type.

I16(I16<A>)

The 16-bit signed integer type.

I32(I32<A>)

The 32-bit signed integer type.

I64(I64<A>)

The 64-bit signed integer type.

I128(I128<A>)

The 128-bit signed integer type.

U8(U8<A>)

The 8-bit unsigned integer type.

U16(U16<A>)

The 16-bit unsigned integer type.

U32(U32<A>)

The 32-bit unsigned integer type.

U64(U64<A>)

The 64-bit unsigned integer type.

U128(U128<A>)

The 128-bit unsigned integer type.

Scalar(Scalar<A>)

The scalar type (scalar field).

Signature(Box<Signature<A>>)

The signature type.

String(StringType<A>)

The string type.

Implementations

impl<A: Aleo> Literal<A>

pub fn cast(&self, to_type: LiteralType) -> Result<Self>

Casts the literal to the given literal type.

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

The hierarchy of casting is as follows:

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

Note that casting to left along the hierarchy always preserves information.

impl<A: Aleo> Literal<A>

pub fn cast_lossy(&self, to_type: LiteralType) -> Result<Self>

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

This method makes a best-effort attempt to preserve all bits of information, but it is not guaranteed to do so.

The hierarchy of casting is as follows:

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

Note that casting to left along the hierarchy always preserves information.

impl<A: Aleo> Literal<A>

pub fn from_bits_le(variant: &U8<A>, bits_le: &[Boolean<A>]) -> Self

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

pub fn from_bits_be(variant: &U8<A>, bits_be: &[Boolean<A>]) -> Self

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

impl<A: Aleo> Literal<A>

pub fn size_in_bits(&self) -> U16<A>

Returns the number of bits of this literal.

impl<A: Aleo> Literal<A>

pub fn to_type(&self) -> LiteralType

Returns the type name of the literal.

impl<A: Aleo> Literal<A>

pub fn variant(&self) -> U8<A>

Returns the variant of the literal.

impl<A: Aleo> Literal<A>

pub fn type_name(&self) -> &str

Returns the type name of the literal.

Trait Implementations

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

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: Aleo> Debug for Literal<A>

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

Formats the value using the given formatter.

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

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

Formats the value using the given formatter.

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

fn eject_mode(&self) -> Mode

Ejects the mode of the literal.

fn eject_value(&self) -> Self::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: Aleo> Equal for Literal<A>

fn is_equal(&self, other: &Self) -> Self::Output

Returns true if self and other are equal.

fn is_not_equal(&self, other: &Self) -> Self::Output

Returns true if self and other are not equal.

type Output = Boolean<A>

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

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

Returns a new Plaintext from a Literal.

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

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

Returns a new Plaintext from a Literal.

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

fn from_str(string: &str) -> Result<Self>

Parses a string into a literal circuit.

type Err = Error

The associated error which can be returned from parsing.

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

fn new(mode: Mode, value: Self::Primitive) -> Self

Initializes a new literal from a primitive.

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

fn constant(value: Self::Primitive) -> Self

where Self: Sized,

Initializes a constant of the given primitive value.

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

fn parse(string: &str) -> ParserResult<'_, Self>

Parses a string into a literal.

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

fn write_bits_le(&self, vec: &mut Vec<Boolean<A>>)

Returns the little-endian bits of the literal.

fn write_bits_be(&self, vec: &mut Vec<Boolean<A>>)

Returns the big-endian bits of the literal.

type Boolean = Boolean<A>

fn to_bits_le(&self) -> Vec<Self::Boolean>

Returns the little-endian bits of the circuit.

fn to_bits_be(&self) -> Vec<Self::Boolean>

Returns the big-endian bits of the circuit.

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

fn write_bits_le(&self, vec: &mut Vec<Boolean<A>>)

Returns the little-endian bits of the literal.

fn write_bits_be(&self, vec: &mut Vec<Boolean<A>>)

Returns the big-endian bits of the literal.

type Boolean = Boolean<A>

fn to_bits_le(&self) -> Vec<Self::Boolean>

Returns the little-endian bits of the circuit.

fn to_bits_be(&self) -> Vec<Self::Boolean>

Returns the big-endian bits of the circuit.

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

fn to_fields(&self) -> Vec<Self::Field>

Returns the literal as a list of base field elements.

type Field = Field<A>

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

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

Returns the literal as a list of base field elements.

type Field = Field<A>