Enum snarkvm_console_program::LiteralType

pub enum LiteralType {
    Address,
    Boolean,
    Field,
    Group,
    I8,
    I16,
    I32,
    I64,
    I128,
    U8,
    U16,
    U32,
    U64,
    U128,
    Scalar,
    Signature,
    String,
}

Variants

Address

The Aleo address type.

Boolean

The boolean type.

Field

The field type (base field).

Group

The group type (affine).

I8

The 8-bit signed integer type.

I16

The 16-bit signed integer type.

I32

The 32-bit signed integer type.

I64

The 64-bit signed integer type.

I128

The 128-bit signed integer type.

U8

The 8-bit unsigned integer type.

U16

The 16-bit unsigned integer type.

U32

The 32-bit unsigned integer type.

U64

The 64-bit unsigned integer type.

U128

The 128-bit unsigned integer type.

Scalar

The scalar type (scalar field).

Signature

The signature type.

String

The string type.

Implementations

impl LiteralType

pub fn type_name(&self) -> &str

Returns the literal type name.

pub fn type_id(&self) -> u8

Returns the unique numeric identifier for the literal type.

Trait Implementations

impl Clone for LiteralType

fn clone(&self) -> LiteralType

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for LiteralType

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

Prints the literal type as a string.

impl<'de> Deserialize<'de> for LiteralType

fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error>

Deserializes the literal type from a string or bytes.

impl Display for LiteralType

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

Prints the literal type as a string.

impl<N: Network> From<LiteralType> for PlaintextType<N>

fn from(literal: LiteralType) -> Self

Initializes a plaintext type from a literal type.

impl FromBytes for LiteralType

fn read_le<R: Read>(reader: R) -> IoResult<Self>

Reads Self from reader as little-endian bytes.

fn from_bytes_le(bytes: &[u8]) -> Result<Self, Error>

where Self: Sized,

Returns Self from a byte array in little-endian order.

impl FromPrimitive for LiteralType

fn from_i64(n: i64) -> Option<Self>

Converts an i64 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_u64(n: u64) -> Option<Self>

Converts an u64 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_isize(n: isize) -> Option<Self>

Converts an isize to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_i8(n: i8) -> Option<Self>

Converts an i8 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_i16(n: i16) -> Option<Self>

Converts an i16 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_i32(n: i32) -> Option<Self>

Converts an i32 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_i128(n: i128) -> Option<Self>

Converts an i128 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_usize(n: usize) -> Option<Self>

Converts a usize to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_u8(n: u8) -> Option<Self>

Converts an u8 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_u16(n: u16) -> Option<Self>

Converts an u16 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_u32(n: u32) -> Option<Self>

Converts an u32 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_u128(n: u128) -> Option<Self>

Converts an u128 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_f32(n: f32) -> Option<Self>

Converts a f32 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_f64(n: f64) -> Option<Self>

Converts a f64 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

impl FromStr for LiteralType

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

Returns a literal type from a string literal.

type Err = Error

The associated error which can be returned from parsing.

impl Hash for LiteralType

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

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 Parser for LiteralType

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

Parses a string into a literal type.

impl PartialEq for LiteralType

fn eq(&self, other: &LiteralType) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for LiteralType

fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error>

Serializes the literal type into string or bytes.

impl ToBytes for LiteralType

fn write_le<W: Write>(&self, writer: W) -> IoResult<()>

Writes self into writer as little-endian bytes.

fn to_bytes_le(&self) -> Result<Vec<u8>, Error>

where Self: Sized,

Returns self as a byte array in little-endian order.

impl Copy for LiteralType

impl Eq for LiteralType

impl StructuralPartialEq for LiteralType