Enum ESExpr

pub enum ESExpr<'a> {
    Constructor(ESExprConstructor<'a>),
    Bool(bool),
    Int(Cow<'a, BigInt>),
    Str(CowStr<'a>),
    Float16(f16),
    Float32(f32),
    Float64(f64),
    Array8(Cow<'a, [u8]>),
    Array16(Cow<'a, [u16]>),
    Array32(Cow<'a, [u32]>),
    Array64(Cow<'a, [u64]>),
    Array128(Cow<'a, [u128]>),
    Null(Cow<'a, BigUint>),
}

Representation of an ESExpr value. Must be a constructor, bool, int, string, float32, float64, {int,uint}{8,16,32,64} or null.

Variants

Constructor(ESExprConstructor<'a>)

A constructor expression. Can contain positional and keyword arguments.

Bool(bool)

A bool value.

Int(Cow<'a, BigInt>)

An integer value.

Str(CowStr<'a>)

A string value.

Float16(f16)

A float16 value.

Float32(f32)

A float32 value.

Float64(f64)

A float64 value.

Array8(Cow<'a, [u8]>)

An array of 8-bit values

Array16(Cow<'a, [u16]>)

An array of 16-bit values

Array32(Cow<'a, [u32]>)

An array of 32-bit values

Array64(Cow<'a, [u64]>)

An array of 64-bit values

Array128(Cow<'a, [u128]>)

An array of 128-bit values

Null(Cow<'a, BigUint>)

A Null value.

Implementations

impl<'a> ESExpr<'a>

pub fn constructor<'b, S: Into<CowStr<'b>>, A: Into<ConstructorArgs<'a>>, K: Into<KeywordArgs<'a>>>( name: S, args: A, kwargs: K, ) -> Self

where 'b: 'a,

Create a new constructor expression

pub fn tag<'b>(&'b self) -> ESExprTag<'b>

Get the tag of an expression.

pub fn as_owned(&self) -> ESExpr<'static>

Performs a deep clone of the value.

pub fn into_owned(self) -> ESExpr<'static>

Ensures that any borrowed values are converted to owned values.

pub fn as_borrowed<'b>(&'b self) -> ESExpr<'b>

where 'a: 'b,

Creates an ESExpr value from a reference without making a deep copy.

Trait Implementations

impl<'a> Clone for ESExpr<'a>

fn clone(&self) -> ESExpr<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for ESExpr<'a>

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

Formats the value using the given formatter.

impl<'a> ESExprCodec<'a> for ESExpr<'a>

const TAGS: ESExprTagSet = ESExprTagSet::All

The tags of the encoded expressions that this type can produce.

fn encode_esexpr(&'a self) -> ESExpr<'a>

Encode this value into an expression.

fn decode_esexpr(expr: ESExpr<'a>) -> Result<Self, DecodeError>

Decode an expression into a value.

impl<'a> ESExprEncodedEq for ESExpr<'a>

fn is_encoded_eq(&self, other: &Self) -> bool

Determines whether two values are equal when encoded as ESExpr.

impl<'a, 'b> PartialEq<ESExpr<'b>> for ESExpr<'a>

fn eq(&self, other: &ESExpr<'b>) -> 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<'a> Eq for ESExpr<'a>