Enum Ast 

pub enum Ast {
    Bool(bool),
    I8(i8),
    I16(i16),
    I32(i32),
    I64(i64),
    U8(u8),
    U16(u16),
    U32(u32),
    U64(u64),
    F32(f32),
    F64(f64),
    Char(char),
    Str(String),
    Bytes(Vec<u8>),
    None,
    Some(Box<Ast>),
    Unit,
    UnitStruct(&'static str),
    UnitVariant {
        name: &'static str,
        variant_index: u32,
        variant: &'static str,
    },
    NewtypeStruct {
        name: &'static str,
        value: Box<Ast>,
    },
    NewtypeVariant {
        name: &'static str,
        variant_index: u32,
        variant: &'static str,
        value: Box<Ast>,
    },
    Seq {
        len: Option<usize>,
        ops: Vec<Seq>,
    },
    Tuple {
        len: usize,
        ops: Vec<Tuple>,
    },
    TupleStruct {
        name: &'static str,
        len: usize,
        ops: Vec<TupleStruct>,
    },
    TupleVariant {
        name: &'static str,
        variant_index: u32,
        variant: &'static str,
        len: usize,
        ops: Vec<TupleVariant>,
    },
    Map {
        len: Option<usize>,
        ops: Vec<Map>,
    },
    Struct {
        name: &'static str,
        len: usize,
        ops: Vec<Struct>,
    },
    StructVariant {
        name: &'static str,
        variant_index: u32,
        variant: &'static str,
        len: usize,
        ops: Vec<StructVariant>,
    },
}

Represent calls made to serde::Serializer during serialization.

Variants

Bool(bool)

serde::Serializer::serialize_bool

I8(i8)

serde::Serializer::serialize_i8

I16(i16)

serde::Serializer::serialize_i16

I32(i32)

serde::Serializer::serialize_i32

I64(i64)

serde::Serializer::serialize_i64

U8(u8)

serde::Serializer::serialize_u8

U16(u16)

serde::Serializer::serialize_u16

U32(u32)

serde::Serializer::serialize_u32

U64(u64)

serde::Serializer::serialize_u64

F32(f32)

serde::Serializer::serialize_f32

F64(f64)

serde::Serializer::serialize_f64

Char(char)

serde::Serializer::serialize_char

Str(String)

serde::Serializer::serialize_str

Bytes(Vec<u8>)

serde::Serializer::serialize_bytes

None

serde::Serializer::serialize_none

Some(Box<Ast>)

serde::Serializer::serialize_some

Unit

serde::Serializer::serialize_unit

UnitStruct(&'static str)

serde::Serializer::serialize_unit_struct

UnitVariant

serde::Serializer::serialize_unit_variant

Fields

name: &'static str

name

variant_index: u32

variant_index

variant: &'static str

variant

NewtypeStruct

serde::Serializer::serialize_newtype_struct

Fields

name: &'static str

name

value: Box<Ast>

value

NewtypeVariant

serde::Serializer::serialize_newtype_variant

Fields

name: &'static str

name

variant_index: u32

variant_index

variant: &'static str

variant

value: Box<Ast>

value

Seq

serde::Serializer::serialize_seq

Fields

len: Option<usize>

len

ops: Vec<Seq>

serde::ser::SerializeSeq operations

Tuple

serde::Serializer::serialize_tuple

Fields

len: usize

len

ops: Vec<Tuple>

serde::ser::SerializeTuple operations

TupleStruct

serde::Serializer::serialize_tuple_struct

Fields

name: &'static str

name

len: usize

len

ops: Vec<TupleStruct>

serde::ser::SerializeTupleStruct operations

TupleVariant

serde::Serializer::serialize_tuple_variant

Fields

name: &'static str

name

variant_index: u32

variant_index

variant: &'static str

variant

len: usize

len

ops: Vec<TupleVariant>

serde::ser::SerializeTupleVariant operations

Map

serde::Serializer::serialize_map

Fields

len: Option<usize>

len

ops: Vec<Map>

serde::ser::SerializeMap operations

Struct

serde::Serializer::serialize_struct

Fields

name: &'static str

name

len: usize

len

ops: Vec<Struct>

serde::ser::SerializeStruct operations

StructVariant

serde::Serializer::serialize_struct_variant

Fields

name: &'static str

name

variant_index: u32

variant_index

variant: &'static str

variant

len: usize

len

ops: Vec<StructVariant>

serde::ser::SerializeStructVariant operations

Trait Implementations

impl Clone for Ast

fn clone(&self) -> Ast

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Ast

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

Formats the value using the given formatter.

impl Display for Ast

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

Formats the value using the given formatter.

impl PartialEq for Ast

fn eq(&self, other: &Ast) -> 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 Serialize for Ast

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

where S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Ast