Enum Operation

pub enum Operation<'a> {
    Invalid,
    Dfg,
    Cfg,
    Block,
    DefineFunc {
        decl: &'a FuncDecl<'a>,
    },
    DeclareFunc {
        decl: &'a FuncDecl<'a>,
    },
    CallFunc {
        func: TermId,
    },
    LoadFunc {
        func: TermId,
    },
    Custom {
        operation: NodeId,
    },
    CustomFull {
        operation: NodeId,
    },
    DefineAlias {
        decl: &'a AliasDecl<'a>,
        value: TermId,
    },
    DeclareAlias {
        decl: &'a AliasDecl<'a>,
    },
    TailLoop,
    Conditional,
    Tag {
        tag: u16,
    },
    DeclareConstructor {
        decl: &'a ConstructorDecl<'a>,
    },
    DeclareOperation {
        decl: &'a OperationDecl<'a>,
    },
    Import {
        name: &'a str,
    },
}

Operations that nodes can perform.

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.

DefineFunc

Function definitions.

Fields

decl: &'a FuncDecl<'a>

The declaration of the function to be defined.

DeclareFunc

Function declarations.

Fields

decl: &'a FuncDecl<'a>

The function to be declared.

CallFunc

Function calls.

Fields

func: TermId

The function to be called.

LoadFunc

Function constants.

Fields

func: TermId

The function to be loaded.

Custom

Custom operation.

The node’s parameters correspond to the explicit parameter of the custom operation, leaving out the implicit parameters. Once the declaration of the custom operation becomes known by resolving the reference, the node can be transformed into a Operation::CustomFull by inferring terms for the implicit parameters or at least filling them in with a wildcard term.

Fields

operation: NodeId

The symbol of the custom operation.

CustomFull

Custom operation with full parameters.

The node’s parameters correspond to both the explicit and implicit parameters of the custom operation. Since this can be tedious to write, the Operation::Custom variant can be used to indicate that the implicit parameters should be inferred.

Fields

operation: NodeId

The symbol of the custom operation.

DefineAlias

Alias definitions.

Fields

decl: &'a AliasDecl<'a>

The declaration of the alias to be defined.

value: TermId

The value of the alias.

DeclareAlias

Alias declarations.

Fields

decl: &'a AliasDecl<'a>

The alias to be declared.

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

Tag

Create an ADT value from a sequence of inputs.

Fields

tag: u16

The tag of the ADT value.

DeclareConstructor

Declaration for a term constructor.

Nodes with this operation must be within a module region.

Fields

decl: &'a ConstructorDecl<'a>

The declaration of the constructor.

DeclareOperation

Declaration for a operation.

Nodes with this operation must be within a module region.

Fields

decl: &'a OperationDecl<'a>

The declaration of the operation.

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>