Enum SequenceConstructorInstruction 

pub enum SequenceConstructorInstruction {
    AnalyzeString(Box<AnalyzeString>),
    ApplyImports(Box<ApplyImports>),
    ApplyTemplates(Box<ApplyTemplates>),
    Assert(Box<Assert>),
    Attribute(Box<Attribute>),
    Break(Box<Break>),
    CallTemplate(Box<CallTemplate>),
    Choose(Box<Choose>),
    Comment(Box<Comment>),
    Copy(Box<Copy>),
    CopyOf(Box<CopyOf>),
    Document(Box<Document>),
    Element(Box<Element>),
    Evaluate(Box<Evaluate>),
    Fallback(Box<Fallback>),
    ForEach(Box<ForEach>),
    ForEachGroup(Box<ForEachGroup>),
    Fork(Box<Fork>),
    If(Box<If>),
    Iterate(Box<Iterate>),
    Map(Box<Map>),
    MapEntry(Box<MapEntry>),
    Merge(Box<Merge>),
    Message(Box<Message>),
    Namespace(Box<Namespace>),
    NextIteration(Box<NextIteration>),
    NextMatch(Box<NextMatch>),
    Number(Box<Number>),
    OnEmpty(Box<OnEmpty>),
    OnNonEmpty(Box<OnNonEmpty>),
    PerformSort(Box<PerformSort>),
    ProcessingInstruction(Box<ProcessingInstruction>),
    ResultDocument(Box<ResultDocument>),
    Sequence(Box<Sequence>),
    SourceDocument(Box<SourceDocument>),
    Text(Box<Text>),
    Try(Box<Try>),
    ValueOf(Box<ValueOf>),
    Variable(Box<Variable>),
    WherePopulated(Box<WherePopulated>),
}

Variants

AnalyzeString(Box<AnalyzeString>)

ApplyImports(Box<ApplyImports>)

ApplyTemplates(Box<ApplyTemplates>)

Assert(Box<Assert>)

Attribute(Box<Attribute>)

Break(Box<Break>)

CallTemplate(Box<CallTemplate>)

Choose(Box<Choose>)

Comment(Box<Comment>)

Copy(Box<Copy>)

CopyOf(Box<CopyOf>)

Document(Box<Document>)

Element(Box<Element>)

Evaluate(Box<Evaluate>)

Fallback(Box<Fallback>)

ForEach(Box<ForEach>)

ForEachGroup(Box<ForEachGroup>)

Fork(Box<Fork>)

If(Box<If>)

Iterate(Box<Iterate>)

Map(Box<Map>)

MapEntry(Box<MapEntry>)

Merge(Box<Merge>)

Message(Box<Message>)

Namespace(Box<Namespace>)

NextIteration(Box<NextIteration>)

NextMatch(Box<NextMatch>)

Number(Box<Number>)

OnEmpty(Box<OnEmpty>)

OnNonEmpty(Box<OnNonEmpty>)

PerformSort(Box<PerformSort>)

ProcessingInstruction(Box<ProcessingInstruction>)

ResultDocument(Box<ResultDocument>)

Sequence(Box<Sequence>)

SourceDocument(Box<SourceDocument>)

Text(Box<Text>)

Try(Box<Try>)

ValueOf(Box<ValueOf>)

Variable(Box<Variable>)

WherePopulated(Box<WherePopulated>)

Trait Implementations

impl Clone for SequenceConstructorInstruction

fn clone(&self) -> SequenceConstructorInstruction

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SequenceConstructorInstruction

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

Formats the value using the given formatter.

impl<'_enum> From<&'_enum SequenceConstructorInstruction> for SequenceConstructorName

fn from(val: &'_enum SequenceConstructorInstruction) -> SequenceConstructorName

Converts to this type from the input type.

impl From<SequenceConstructorInstruction> for SequenceConstructorItem

fn from(i: SequenceConstructorInstruction) -> Self

Converts to this type from the input type.

impl From<SequenceConstructorInstruction> for SequenceConstructorName

fn from(val: SequenceConstructorInstruction) -> SequenceConstructorName

Converts to this type from the input type.

impl IntoDiscriminant for SequenceConstructorInstruction

type Discriminant = SequenceConstructorName

Enum listing the same variants as this enum but without any data fields

fn discriminant(&self) -> Self::Discriminant

impl PartialEq for SequenceConstructorInstruction

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

impl StructuralPartialEq for SequenceConstructorInstruction