Enum ArgShape

pub enum ArgShape {
    Right {
        pattern: ArgPattern,
    },
    Left1,
    InfixGreedy,
}

Shape of arguments with direction to match since.

Note: We currently only support

• Direction::Right with any ArgPattern
• Direction::Left with ArgPattern::FixedLenTerm(1)
• Direction::Infix with ArgPattern::Greedy

Variants

Right

A command that associates with the right side of items.

E.g. \hat

Fields

pattern: ArgPattern

The pattern to match the arguments

Left1

A command that associates with the left side of items, and with ArgPattern::FixedLenTerm(1).

E.g. \limits

InfixGreedy

A command that associates with both side of items, and with ArgPattern::Greedy, also known as infix operators.

E.g. \over

Trait Implementations

impl Archive for ArgShape

where ArgPattern: Archive,

type Archived = ArchivedArgShape

The archived representation of this type.

type Resolver = ArgShapeResolver

The resolver for this type. It must contain all the additional information from serializing needed to make the archived type from the normal type.

unsafe fn resolve( &self, pos: usize, resolver: <ArgShape as Archive>::Resolver, out: *mut <ArgShape as Archive>::Archived, )

Creates the archived version of this value at the given position and writes it to the given output.

impl Clone for ArgShape

fn clone(&self) -> ArgShape

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ArgShape

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ArgShape

fn deserialize<__D>( __deserializer: __D, ) -> Result<ArgShape, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<__D> Deserialize<ArgShape, __D> for <ArgShape as Archive>::Archived

where __D: Fallible + ?Sized, ArgPattern: Archive, <ArgPattern as Archive>::Archived: Deserialize<ArgPattern, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<ArgShape, <__D as Fallible>::Error>

Deserializes using the given deserializer

impl<__S> Serialize<__S> for ArgShape

where __S: Fallible + ?Sized, ArgPattern: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<ArgShape as Archive>::Resolver, <__S as Fallible>::Error>

Writes the dependencies for the object and returns a resolver that can create the archived type.

impl Serialize for ArgShape

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.