Struct valkyrie_ast::ForLoop

pub struct ForLoop {
    pub pattern: PatternNode,
    pub iterator: ExpressionKind,
    pub condition: Option<ExpressionKind>,
    pub label: Option<IdentifierNode>,
    pub body: StatementBlock,
    pub span: Range<u32>,
}

for ... in ... if ... #label {...}

Simple For Loop

for i in j if c1 {
    if c2 {
        continue
    }
    else if c3 {
        break
    }
    else {
        return
    }
}
"residual expression"

j = j.into_iterator()
let looper = {
    
    if c2 {
        looper()
    }
    else if c3 {
        break()
    }
    else {
        return
    }
}
let break = {
    "other"
}

j = j.into_iterator()
let looper = {
    
    if c2 {
        looper()
    }
    else if c3 {
        break()
    }
    else {
        return
    }
}
let break = {
    "other"
}

loop switch label {
᳀function.1.start:
    j = j.into_iterator()
᳀for.1.start:
    let next = j.next();


}

loop {
    ᳀for.1.start
    let next = j.next();

    if next != null && c1 {
        ᳀if.1.head
        if c2 {
            ⤮for.1.start
        }
        else if c3 {
            ⤮for.1.tail
        }
        else {
            ⤮function.1.return
        }
    }
    else {
        break
    }
    ᳀for.1.end
}
⤮for.1.tail

᳀function.1.return

Nested For Loop

for i in j #outer {
    for x in y #inner {
        if c1 {
            continue #outer
        }
        if c2 {
            continue #inner
        }
    }
}

Fields

pattern: PatternNode

for pattern

iterator: ExpressionKind

in iterator

condition: Option<ExpressionKind>

if condition

label: Option<IdentifierNode>

#label

body: StatementBlock

{ body }

span: Range<u32>

The range of the node

Implementations

impl ForLoop

pub fn standardization( self, iterator: IdentifierNode ) -> (VariableDeclaration, LoopStatement)

Trait Implementations

impl Clone for ForLoop

fn clone(&self) -> ForLoop

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ForLoop

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

Formats the value using the given formatter.

impl From<ForLoop> for StatementKind

fn from(o: ForLoop) -> Self

Converts to this type from the input type.

impl Hash for ForLoop

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 PartialEq for ForLoop

fn eq(&self, other: &ForLoop) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl ValkyrieNode for ForLoop

fn get_range(&self) -> Range<usize>

The range of the node

fn get_start(&self) -> usize

Get the start of the node

fn get_end(&self) -> usize

Get the end of the node

impl Eq for ForLoop

impl StructuralPartialEq for ForLoop