Enum Node 

pub enum Node {
    Text(String),
    Echo {
        expr: Expr,
        raw: bool,
    },
    If {
        branches: Vec<(Condition, Vec<Node>)>,
        otherwise: Option<Vec<Node>>,
    },
    Foreach {
        collection: Expr,
        key: Option<String>,
        value: String,
        body: Vec<Node>,
    },
    Include(String),
    Yield(String),
    Section {
        name: String,
        body: Vec<Node>,
    },
}

One piece of a template.

Variants

Text(String)

Literal text.

Echo

{{ expr }} (escaped) or {!! expr !!} (raw).

Fields

expr: Expr

The path to read.

raw: bool

Whether to emit the value without HTML-escaping it.

If

@if … @elseif … @else … @endif.

Fields

branches: Vec<(Condition, Vec<Node>)>

Each (condition, body) in order.

otherwise: Option<Vec<Node>>

The @else body, if there is one.

Foreach

@foreach(items as item) … @endforeach.

Fields

collection: Expr

The collection to walk.

key: Option<String>

The variable bound to each key, for key => value form.

value: String

The variable bound to each element.

body: Vec<Node>

The loop body.

Include(String)

@include('partial').

Yield(String)

@yield('name') — where a layout drops a child’s section.

Section

@section('name') … @endsection.

Fields

name: String

The section’s name.

body: Vec<Node>

Its content.

Trait Implementations

impl Clone for Node

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Node

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

Formats the value using the given formatter.

impl PartialEq for Node

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for Node