Enum snarkvm_wasm::program::LiteralType

pub enum LiteralType {
    Address,
    Boolean,
    Field,
    Group,
    I8,
    I16,
    I32,
    I64,
    I128,
    U8,
    U16,
    U32,
    U64,
    U128,
    Scalar,
    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).

String

The string type.

Implementations

impl LiteralType

pub fn type_name(&self) -> &str

Returns the literal type name.

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<(), Error>

Prints the literal type as a string.

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

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

Deserializes the literal type from a string or bytes.

impl Display for LiteralType

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

Prints the literal type as a string.

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

fn from(literal: LiteralType) -> PlaintextType<N>

Initializes a plaintext type from a literal type.

impl FromBytes for LiteralType

fn read_le<R>(reader: R) -> Result<LiteralType, Error>where
    R: Read,

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

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

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<LiteralType, Error>

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

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

Parses a string into a literal type.

impl PartialEq<LiteralType> 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>(
    &self,
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
    S: Serializer,

Serializes the literal type into string or bytes.

impl ToBytes for LiteralType

fn write_le<W>(&self, writer: W) -> Result<(), Error>where
    W: Write,

Writes self into writer as little-endian bytes.

fn to_bytes_le(&self) -> Result<Vec<u8, Global>, Error>where
    Self: Sized,

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

impl Copy for LiteralType

impl Eq for LiteralType

impl StructuralEq for LiteralType

impl StructuralPartialEq for LiteralType