Enum Piece 

pub enum Piece {
    Var {
        name: &'static str,
        index: usize,
    },
    Int(i128),
    Computed {
        text: &'static str,
        work: fn(&[Option<i128>]) -> Option<i128>,
    },
    App {
        head: &'static str,
        arity: usize,
    },
}

One piece of a replacement, in the pre-order that builds it.

Variants

Var

Whatever the pattern bound at this position.

Fields

name: &'static str

The name the rule gave it, for anything that has to say what it did.

index: usize

Which binding of the match it is.

Int(i128)

A constant written in the rule.

Computed

A constant the rule works out from the ones the pattern matched.

This is what lets a rule be written once per width rather than once per constant. A shift that stands in for a multiplication by a power of two shifts by the log of that power, and the log is a number no rule can write down until it has seen which power it matched.

Fields

text: &'static str

The computation as the rule file writes it, for anything that has to say what it did.

work: fn(&[Option<i128>]) -> Option<i128>

What it works out.

App

A term the rule writes, which is an instruction once the caller has built it.

Fields

head: &'static str

The name in head position.

arity: usize

How many arguments it takes.

Trait Implementations

impl Debug for Piece

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

Formats the value using the given formatter.