Struct Sequence9 

pub struct Sequence9<T0, TR0, T1, TR1, T2, TR2, T3, TR3, T4, TR4, T5, TR5, T6, TR6, T7, TR7, T8, TR8> {
    pub field_0: T0,
    pub field_1: T1,
    pub field_2: T2,
    pub field_3: T3,
    pub field_4: T4,
    pub field_5: T5,
    pub field_6: T6,
    pub field_7: T7,
    pub field_8: T8,
    /* private fields */
}

Sequence type generated by pest::sequence_type!.

• 0: No trivia.
• 1: Optional trivia.
• 2: Mandatory trivia.

Fields

field_0: T0

Field for T0.

field_1: T1

Field for T1.

field_2: T2

Field for T2.

field_3: T3

Field for T3.

field_4: T4

Field for T4.

field_5: T5

Field for T5.

field_6: T6

Field for T6.

field_7: T7

Field for T7.

field_8: T8

Field for T8.

Implementations

impl<'i, T0, TR0, T1, TR1, T2, TR2, T3, TR3, T4, TR4, T5, TR5, T6, TR6, T7, TR7, T8, TR8> Sequence9<T0, TR0, T1, TR1, T2, TR2, T3, TR3, T4, TR4, T5, TR5, T6, TR6, T7, TR7, T8, TR8>

pub fn as_tuple(&self) -> (&T0, &T1, &T2, &T3, &T4, &T5, &T6, &T7, &T8)

As a tuple of references.

pub fn into_tuple(self) -> (T0, T1, T2, T3, T4, T5, T6, T7, T8)

Into a tuple of values.

Trait Implementations

impl<T0, TR0, T1, TR1, T2, TR2, T3, TR3, T4, TR4, T5, TR5, T6, TR6, T7, TR7, T8, TR8> Clone for Sequence9<T0, TR0, T1, TR1, T2, TR2, T3, TR3, T4, TR4, T5, TR5, T6, TR6, T7, TR7, T8, TR8>

where T0: Clone, TR0: Clone, T1: Clone, TR1: Clone, T2: Clone, TR2: Clone, T3: Clone, TR3: Clone, T4: Clone, TR4: Clone, T5: Clone, TR5: Clone, T6: Clone, TR6: Clone, T7: Clone, TR7: Clone, T8: Clone, TR8: Clone,

fn clone( &self, ) -> Sequence9<T0, TR0, T1, TR1, T2, TR2, T3, TR3, T4, TR4, T5, TR5, T6, TR6, T7, TR7, T8, TR8>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T0, TR0, T1, TR1, T2, TR2, T3, TR3, T4, TR4, T5, TR5, T6, TR6, T7, TR7, T8, TR8> Debug for Sequence9<T0, TR0, T1, TR1, T2, TR2, T3, TR3, T4, TR4, T5, TR5, T6, TR6, T7, TR7, T8, TR8>

where T0: Debug, TR0: Debug, T1: Debug, TR1: Debug, T2: Debug, TR2: Debug, T3: Debug, TR3: Debug, T4: Debug, TR4: Debug, T5: Debug, TR5: Debug, T6: Debug, TR6: Debug, T7: Debug, TR7: Debug, T8: Debug, TR8: Debug,

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

Formats the value using the given formatter.

impl<T0, TR0, T1, TR1, T2, TR2, T3, TR3, T4, TR4, T5, TR5, T6, TR6, T7, TR7, T8, TR8> Eq for Sequence9<T0, TR0, T1, TR1, T2, TR2, T3, TR3, T4, TR4, T5, TR5, T6, TR6, T7, TR7, T8, TR8>

where T0: Eq, TR0: Eq, T1: Eq, TR1: Eq, T2: Eq, TR2: Eq, T3: Eq, TR3: Eq, T4: Eq, TR4: Eq, T5: Eq, TR5: Eq, T6: Eq, TR6: Eq, T7: Eq, TR7: Eq, T8: Eq, TR8: Eq,

impl<T0, TR0, T1, TR1, T2, TR2, T3, TR3, T4, TR4, T5, TR5, T6, TR6, T7, TR7, T8, TR8> Hash for Sequence9<T0, TR0, T1, TR1, T2, TR2, T3, TR3, T4, TR4, T5, TR5, T6, TR6, T7, TR7, T8, TR8>

where T0: Hash, TR0: Hash, T1: Hash, TR1: Hash, T2: Hash, TR2: Hash, T3: Hash, TR3: Hash, T4: Hash, TR4: Hash, T5: Hash, TR5: Hash, T6: Hash, TR6: Hash, T7: Hash, TR7: Hash, T8: Hash, TR8: Hash,

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<R, T0, TR0, T1, TR1, T2, TR2, T3, TR3, T4, TR4, T5, TR5, T6, TR6, T7, TR7, T8, TR8> PairContainer<R> for Sequence9<T0, TR0, T1, TR1, T2, TR2, T3, TR3, T4, TR4, T5, TR5, T6, TR6, T7, TR7, T8, TR8>

where T0: PairContainer<R>, T1: PairContainer<R>, T2: PairContainer<R>, T3: PairContainer<R>, T4: PairContainer<R>, T5: PairContainer<R>, T6: PairContainer<R>, T7: PairContainer<R>, T8: PairContainer<R>,

fn for_each_child_pair(&self, f: &mut impl FnMut(Pair<R>))

For each child pair.

fn for_self_or_for_each_child_pair(&self, f: &mut impl FnMut(Pair<R>))

for Self as a pair if it is, otherwise for each child pair.

fn vec_children_pairs(&self) -> Vec<Pair<R>>

Convert children pairs into a Vec.

impl<T0, TR0, T1, TR1, T2, TR2, T3, TR3, T4, TR4, T5, TR5, T6, TR6, T7, TR7, T8, TR8> PartialEq for Sequence9<T0, TR0, T1, TR1, T2, TR2, T3, TR3, T4, TR4, T5, TR5, T6, TR6, T7, TR7, T8, TR8>

where T0: PartialEq, TR0: PartialEq, T1: PartialEq, TR1: PartialEq, T2: PartialEq, TR2: PartialEq, T3: PartialEq, TR3: PartialEq, T4: PartialEq, TR4: PartialEq, T5: PartialEq, TR5: PartialEq, T6: PartialEq, TR6: PartialEq, T7: PartialEq, TR7: PartialEq, T8: PartialEq, TR8: PartialEq,

fn eq( &self, other: &Sequence9<T0, TR0, T1, TR1, T2, TR2, T3, TR3, T4, TR4, T5, TR5, T6, TR6, T7, TR7, T8, TR8>, ) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<T0, TR0, T1, TR1, T2, TR2, T3, TR3, T4, TR4, T5, TR5, T6, TR6, T7, TR7, T8, TR8> StructuralPartialEq for Sequence9<T0, TR0, T1, TR1, T2, TR2, T3, TR3, T4, TR4, T5, TR5, T6, TR6, T7, TR7, T8, TR8>

where T0: PartialEq, TR0: PartialEq, T1: PartialEq, TR1: PartialEq, T2: PartialEq, TR2: PartialEq, T3: PartialEq, TR3: PartialEq, T4: PartialEq, TR4: PartialEq, T5: PartialEq, TR5: PartialEq, T6: PartialEq, TR6: PartialEq, T7: PartialEq, TR7: PartialEq, T8: PartialEq, TR8: PartialEq,

impl<'i, R, T0, TR0, T1, TR1, T2, TR2, T3, TR3, T4, TR4, T5, TR5, T6, TR6, T7, TR7, T8, TR8> TypedNode<'i, R> for Sequence9<T0, TR0, T1, TR1, T2, TR2, T3, TR3, T4, TR4, T5, TR5, T6, TR6, T7, TR7, T8, TR8>

where R: RuleType, T0: TypedNode<'i, R>, TR0: TypedNode<'i, R>, T1: TypedNode<'i, R>, TR1: TypedNode<'i, R>, T2: TypedNode<'i, R>, TR2: TypedNode<'i, R>, T3: TypedNode<'i, R>, TR3: TypedNode<'i, R>, T4: TypedNode<'i, R>, TR4: TypedNode<'i, R>, T5: TypedNode<'i, R>, TR5: TypedNode<'i, R>, T6: TypedNode<'i, R>, TR6: TypedNode<'i, R>, T7: TypedNode<'i, R>, TR7: TypedNode<'i, R>, T8: TypedNode<'i, R>, TR8: TypedNode<'i, R>,

fn try_parse_with_partial( input: Position<'i>, stack: &mut Stack<Span<'i>>, tracker: &mut Tracker<'i, R>, ) -> Option<(Position<'i>, Sequence9<T0, TR0, T1, TR1, T2, TR2, T3, TR3, T4, TR4, T5, TR5, T6, TR6, T7, TR7, T8, TR8>)>

Try parse a part of or all of remained string into a node.

fn check_with_partial( input: Position<'i>, stack: &mut Stack<Span<'i>>, tracker: &mut Tracker<'i, R>, ) -> Option<Position<'i>>

Check whether the some leading part of the result can be accepted.

fn try_parse_with( input: Position<'i>, stack: &mut Stack<Span<'i>>, tracker: &mut Tracker<'i, R>, ) -> Option<Self>

Try parse remained string into a node.

fn try_parse_partial( input: &'i str, ) -> Result<(Position<'i>, Self), Box<Error<R>>>

Try parsing leading part of string into a node.

fn try_parse(input: &'i str) -> Result<Self, Box<Error<R>>>

Try parsing given string into a node.

fn check_with( input: Position<'i>, stack: &mut Stack<Span<'i>>, tracker: &mut Tracker<'i, R>, ) -> bool

Check whether the some leading part of the result can be accepted.

fn check_partial(input: &'i str) -> Result<Position<'i>, Box<Error<R>>>

Try parsing leading part of string into a node.

fn check(input: &'i str) -> Result<(), Box<Error<R>>>

Try parsing given string into a node.