Struct Sequence16 

pub struct Sequence16<T0, TR0, T1, TR1, T2, TR2, T3, TR3, T4, TR4, T5, TR5, T6, TR6, T7, TR7, T8, TR8, T9, TR9, T10, TR10, T11, TR11, T12, TR12, T13, TR13, T14, TR14, T15, TR15> {

    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,
    pub field_9: T9,
    pub field_10: T10,
    pub field_11: T11,
    pub field_12: T12,
    pub field_13: T13,
    pub field_14: T14,
    pub field_15: T15,
    /* 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.

field_9: T9

Field for T9.

field_10: T10

Field for T10.

field_11: T11

Field for T11.

field_12: T12

Field for T12.

field_13: T13

Field for T13.

field_14: T14

Field for T14.

field_15: T15

Field for T15.

Implementations

impl<'i, T0, TR0, T1, TR1, T2, TR2, T3, TR3, T4, TR4, T5, TR5, T6, TR6, T7, TR7, T8, TR8, T9, TR9, T10, TR10, T11, TR11, T12, TR12, T13, TR13, T14, TR14, T15, TR15> Sequence16<T0, TR0, T1, TR1, T2, TR2, T3, TR3, T4, TR4, T5, TR5, T6, TR6, T7, TR7, T8, TR8, T9, TR9, T10, TR10, T11, TR11, T12, TR12, T13, TR13, T14, TR14, T15, TR15>

pub fn as_tuple( &self, ) -> (&T0, &T1, &T2, &T3, &T4, &T5, &T6, &T7, &T8, &T9, &T10, &T11, &T12, &T13, &T14, &T15)

As a tuple of references.

pub fn into_tuple( self, ) -> (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)

Into a tuple of values.

Trait Implementations

impl<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, T9: Clone, TR9: Clone, T10: Clone, TR10: Clone, T11: Clone, TR11: Clone, T12: Clone, TR12: Clone, T13: Clone, TR13: Clone, T14: Clone, TR14: Clone, T15: Clone, TR15: Clone> Clone for Sequence16<T0, TR0, T1, TR1, T2, TR2, T3, TR3, T4, TR4, T5, TR5, T6, TR6, T7, TR7, T8, TR8, T9, TR9, T10, TR10, T11, TR11, T12, TR12, T13, TR13, T14, TR14, T15, TR15>

fn clone( &self, ) -> Sequence16<T0, TR0, T1, TR1, T2, TR2, T3, TR3, T4, TR4, T5, TR5, T6, TR6, T7, TR7, T8, TR8, T9, TR9, T10, TR10, T11, TR11, T12, TR12, T13, TR13, T14, TR14, T15, TR15>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<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, T9: Debug, TR9: Debug, T10: Debug, TR10: Debug, T11: Debug, TR11: Debug, T12: Debug, TR12: Debug, T13: Debug, TR13: Debug, T14: Debug, TR14: Debug, T15: Debug, TR15: Debug> Debug for Sequence16<T0, TR0, T1, TR1, T2, TR2, T3, TR3, T4, TR4, T5, TR5, T6, TR6, T7, TR7, T8, TR8, T9, TR9, T10, TR10, T11, TR11, T12, TR12, T13, TR13, T14, TR14, T15, TR15>

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

Formats the value using the given formatter.

impl<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, T9: Hash, TR9: Hash, T10: Hash, TR10: Hash, T11: Hash, TR11: Hash, T12: Hash, TR12: Hash, T13: Hash, TR13: Hash, T14: Hash, TR14: Hash, T15: Hash, TR15: Hash> Hash for Sequence16<T0, TR0, T1, TR1, T2, TR2, T3, TR3, T4, TR4, T5, TR5, T6, TR6, T7, TR7, T8, TR8, T9, TR9, T10, TR10, T11, TR11, T12, TR12, T13, TR13, T14, TR14, T15, TR15>

fn hash<__H: Hasher>(&self, state: &mut __H)

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, T9, TR9, T10, TR10, T11, TR11, T12, TR12, T13, TR13, T14, TR14, T15, TR15> PairContainer<R> for Sequence16<T0, TR0, T1, TR1, T2, TR2, T3, TR3, T4, TR4, T5, TR5, T6, TR6, T7, TR7, T8, TR8, T9, TR9, T10, TR10, T11, TR11, T12, TR12, T13, TR13, T14, TR14, T15, TR15>

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>, T9: PairContainer<R>, T10: PairContainer<R>, T11: PairContainer<R>, T12: PairContainer<R>, T13: PairContainer<R>, T14: PairContainer<R>, T15: 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: 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, T9: PartialEq, TR9: PartialEq, T10: PartialEq, TR10: PartialEq, T11: PartialEq, TR11: PartialEq, T12: PartialEq, TR12: PartialEq, T13: PartialEq, TR13: PartialEq, T14: PartialEq, TR14: PartialEq, T15: PartialEq, TR15: PartialEq> PartialEq for Sequence16<T0, TR0, T1, TR1, T2, TR2, T3, TR3, T4, TR4, T5, TR5, T6, TR6, T7, TR7, T8, TR8, T9, TR9, T10, TR10, T11, TR11, T12, TR12, T13, TR13, T14, TR14, T15, TR15>

fn eq( &self, other: &Sequence16<T0, TR0, T1, TR1, T2, TR2, T3, TR3, T4, TR4, T5, TR5, T6, TR6, T7, TR7, T8, TR8, T9, TR9, T10, TR10, T11, TR11, T12, TR12, T13, TR13, T14, TR14, T15, TR15>, ) -> 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<'i, R, T0, TR0, T1, TR1, T2, TR2, T3, TR3, T4, TR4, T5, TR5, T6, TR6, T7, TR7, T8, TR8, T9, TR9, T10, TR10, T11, TR11, T12, TR12, T13, TR13, T14, TR14, T15, TR15> TypedNode<'i, R> for Sequence16<T0, TR0, T1, TR1, T2, TR2, T3, TR3, T4, TR4, T5, TR5, T6, TR6, T7, TR7, T8, TR8, T9, TR9, T10, TR10, T11, TR11, T12, TR12, T13, TR13, T14, TR14, T15, TR15>

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>, T9: TypedNode<'i, R>, TR9: TypedNode<'i, R>, T10: TypedNode<'i, R>, TR10: TypedNode<'i, R>, T11: TypedNode<'i, R>, TR11: TypedNode<'i, R>, T12: TypedNode<'i, R>, TR12: TypedNode<'i, R>, T13: TypedNode<'i, R>, TR13: TypedNode<'i, R>, T14: TypedNode<'i, R>, TR14: TypedNode<'i, R>, T15: TypedNode<'i, R>, TR15: TypedNode<'i, R>,

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

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.

impl<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, T9: Eq, TR9: Eq, T10: Eq, TR10: Eq, T11: Eq, TR11: Eq, T12: Eq, TR12: Eq, T13: Eq, TR13: Eq, T14: Eq, TR14: Eq, T15: Eq, TR15: Eq> Eq for Sequence16<T0, TR0, T1, TR1, T2, TR2, T3, TR3, T4, TR4, T5, TR5, T6, TR6, T7, TR7, T8, TR8, T9, TR9, T10, TR10, T11, TR11, T12, TR12, T13, TR13, T14, TR14, T15, TR15>

impl<T0, TR0, T1, TR1, T2, TR2, T3, TR3, T4, TR4, T5, TR5, T6, TR6, T7, TR7, T8, TR8, T9, TR9, T10, TR10, T11, TR11, T12, TR12, T13, TR13, T14, TR14, T15, TR15> StructuralPartialEq for Sequence16<T0, TR0, T1, TR1, T2, TR2, T3, TR3, T4, TR4, T5, TR5, T6, TR6, T7, TR7, T8, TR8, T9, TR9, T10, TR10, T11, TR11, T12, TR12, T13, TR13, T14, TR14, T15, TR15>