Enum ExpressionEnum 

#[repr(u8)]
pub enum ExpressionEnum {
    Function = 102,
    Symbol = 115,
    String = 83,
    ByteArray = 66,
    Integer8 = 67,
    Integer16 = 106,
    Integer32 = 105,
    Integer64 = 76,
    Real64 = 114,
    BigInteger = 73,
    BigReal = 82,
    PackedArray = 193,
    NumericArray = 194,
    Association = 65,
    Rule = 45,
    RuleDelayed = 58,
}

Top-level WXF expression token. #[repr(u8)] discriminants are the wire bytes.

Variants

Function = 102

General expression head[args…], written as a length-prefixed head plus elements (f).

Symbol = 115

A symbol such as System`Plus (s).

String = 83

A UTF-8 string (S).

ByteArray = 66

A raw byte buffer / ByteArray (B).

Integer8 = 67

Machine integer that fits in 8 bits (C).

Integer16 = 106

Machine integer that fits in 16 bits (j).

Integer32 = 105

Machine integer that fits in 32 bits (i).

Integer64 = 76

Machine integer that fits in 64 bits (L).

Real64 = 114

IEEE 754 double-precision real (r).

BigInteger = 73

Arbitrary-precision integer, encoded as its decimal digit string (I).

BigReal = 82

Arbitrary-precision real, encoded as its textual representation (R).

PackedArray = 193

A PackedArray of machine numbers (0xC1).

NumericArray = 194

A NumericArray of fixed-width numbers (0xC2).

Association = 65

An Association of rules (A).

Rule = 45

A Rule (->) entry inside an association (-).

RuleDelayed = 58

A RuleDelayed (:>) entry inside an association (:).

Implementations

impl ExpressionEnum

pub fn name(self) -> &'static str

The Wolfram Language head this token decodes to (e.g. "Integer", "Real", "List"), as used in error and diagnostic messages.

Trait Implementations

impl Clone for ExpressionEnum

fn clone(&self) -> ExpressionEnum

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for ExpressionEnum

impl Debug for ExpressionEnum

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

Formats the value using the given formatter.

impl Eq for ExpressionEnum

impl PartialEq for ExpressionEnum

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl StructuralPartialEq for ExpressionEnum

impl TryFrom<u8> for ExpressionEnum

type Error = TryFromPrimitiveError<ExpressionEnum>

The type returned in the event of a conversion error.

fn try_from( number: u8, ) -> Result<ExpressionEnum, TryFromPrimitiveError<ExpressionEnum>>

Performs the conversion.

impl TryFromPrimitive for ExpressionEnum

const NAME: &'static str = "ExpressionEnum"

type Primitive = u8

type Error = TryFromPrimitiveError<ExpressionEnum>

fn try_from_primitive( number: <ExpressionEnum as TryFromPrimitive>::Primitive, ) -> Result<ExpressionEnum, TryFromPrimitiveError<ExpressionEnum>>