Enum Inst 

pub enum Inst {
    Bool(bool),
    Number(i64),
    Float(f64),
    String(StringId),
    Bytes(Vec<u8>),
    Name(NameId),
    Time(i64),
    Duration(i64),
    List(Vec<InstId>),
    Map {
        keys: Vec<InstId>,
        values: Vec<InstId>,
    },
    Struct {
        fields: Vec<NameId>,
        values: Vec<InstId>,
    },
    Var(NameId),
    ApplyFn {
        function: NameId,
        args: Vec<InstId>,
    },
    Atom {
        predicate: NameId,
        args: Vec<InstId>,
    },
    NegAtom(InstId),
    Eq(InstId, InstId),
    Ineq(InstId, InstId),
    Transform {
        var: Option<NameId>,
        app: InstId,
    },
    Rule {
        head: InstId,
        premises: Vec<InstId>,
        transform: Vec<InstId>,
    },
    Decl {
        atom: InstId,
        descr: Vec<InstId>,
        bounds: Vec<InstId>,
        constraints: Option<InstId>,
    },
    BoundDecl {
        base_terms: Vec<InstId>,
    },
    Constraints {
        consequences: Vec<InstId>,
        alternatives: Vec<Vec<InstId>>,
    },
}

Instructions in the Mangle IR.

Variants

Bool(bool)

Number(i64)

Float(f64)

String(StringId)

A string constant (e.g. “foo”).

Bytes(Vec<u8>)

Name(NameId)

A name constant (e.g. /foo).

Time(i64)

Time as nanoseconds since Unix epoch.

Duration(i64)

Duration as nanoseconds.

List(Vec<InstId>)

A list of values. args point to other Constant-like instructions.

Map

A map of values. keys and values must have same length.

Fields

keys: Vec<InstId>

values: Vec<InstId>

Struct

A struct. fields and values must have same length.

Fields

fields: Vec<NameId>

values: Vec<InstId>

Var(NameId)

A variable.

ApplyFn

Application of a function.

Fields

function: NameId

args: Vec<InstId>

Atom

An atom (predicate application).

Fields

predicate: NameId

args: Vec<InstId>

NegAtom(InstId)

Negation of an atom.

Eq(InstId, InstId)

Equality constraint (left = right).

Ineq(InstId, InstId)

Inequality constraint (left != right).

Transform

A transform statement: let var = app.

Fields

var: Option<NameId>

app: InstId

Rule

A Horn clause (Rule).

Fields

head: InstId

premises: Vec<InstId>

transform: Vec<InstId>

Decl

A Declaration.

Fields

atom: InstId

descr: Vec<InstId>

bounds: Vec<InstId>

constraints: Option<InstId>

BoundDecl

Bound Declaration.

Fields

base_terms: Vec<InstId>

Constraints

Constraints.

Fields

consequences: Vec<InstId>

alternatives: Vec<Vec<InstId>>

Trait Implementations

impl Clone for Inst

fn clone(&self) -> Inst

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Inst

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

Formats the value using the given formatter.

impl PartialEq for Inst

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