Enum Operation

pub enum Operation<'a> {
    Invalid,
    Dfg,
    Cfg,
    Block,
    DefineFunc(&'a Symbol<'a>),
    DeclareFunc(&'a Symbol<'a>),
    Custom(TermId),
    DefineAlias(&'a Symbol<'a>, TermId),
    DeclareAlias(&'a Symbol<'a>),
    TailLoop,
    Conditional,
    DeclareConstructor(&'a Symbol<'a>),
    DeclareOperation(&'a Symbol<'a>),
    Import {
        name: &'a str,
    },
}

Operations that nodes can perform.

See ast::Operation for the AST representation.

Variants

Invalid

Invalid operation to be used as a placeholder. This is useful for modules that have non-contiguous node ids, or modules that have not yet been fully constructed.

Dfg

Data flow graphs.

Cfg

Control flow graphs.

Block

Basic blocks in a control flow graph.

DefineFunc(&'a Symbol<'a>)

Function definitions.

DeclareFunc(&'a Symbol<'a>)

Function declarations.

Custom(TermId)

Custom operation.

DefineAlias(&'a Symbol<'a>, TermId)

Alias definitions.

DeclareAlias(&'a Symbol<'a>)

Alias declarations.

TailLoop

Tail controlled loop. Nodes with this operation contain a dataflow graph that is executed in a loop. The loop body is executed at least once, producing a result that indicates whether to continue the loop or return the result.

Port Types

• Inputs: inputs + rest
• Outputs: outputs + rest
• Sources: inputs + rest
• Targets: (adt [inputs outputs]) + rest

Conditional

Conditional operation.

Port types

• Inputs: [(adt inputs)] + context
• Outputs: outputs

DeclareConstructor(&'a Symbol<'a>)

Declaration for a term constructor.

Nodes with this operation must be within a module region.

DeclareOperation(&'a Symbol<'a>)

Declaration for a operation.

Nodes with this operation must be within a module region.

Import

Import a symbol.

Fields

name: &'a str

The name of the symbol to be imported.

Implementations

impl<'a> Operation<'a>

pub fn symbol(&self) -> Option<&'a str>

Returns the symbol introduced by the operation, if any.

Trait Implementations

impl<'a> Clone for Operation<'a>

fn clone(&self) -> Operation<'a>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for Operation<'a>

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

Formats the value using the given formatter.

impl<'a> Default for Operation<'a>

fn default() -> Operation<'a>

Returns the “default value” for a type.

impl<'a> Hash for Operation<'a>

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<'a> PartialEq for Operation<'a>

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

impl<'a> StructuralPartialEq for Operation<'a>