Enum Fill 

pub enum Fill {
    Const(i64),
    Pattern {
        modulus: i64,
        shift: i64,
    },
    Overrides {
        base: Box<Fill>,
        sets: Vec<(usize, i64)>,
    },
    ConstF(u64),
    FloatOverrides {
        base: u64,
        sets: Vec<(usize, u64)>,
    },
    RealPattern {
        modulus: i64,
        shift: i64,
        divisor: u64,
    },
    Unknown,
}

How an array is FILLED by its build loop — recognized from While iv is less than N: Push <expr> to xs, so a backend host can reproduce the source’s data and a numerics claim can bound the operand range.

Variants

Const(i64)

Every element is the same constant.

Pattern

element[p] = (p % modulus) + shift over the loop counter p.

Fields

modulus: i64

shift: i64

Overrides

A recognized base fill followed by constant element overrides Set item i of xs to v (0-based here).

Fields

base: Box<Fill>

sets: Vec<(usize, i64)>

ConstF(u64)

Every element is the same float constant (its bits, so the fill stays hashable).

FloatOverrides

A float base constant (bits) followed by float element overrides (0-based index, value bits).

Fields

base: u64

sets: Vec<(usize, u64)>

RealPattern

element[p] = ((p % modulus) + shift) / divisor over the loop counter p, a Real (divisor by its bits).

Fields

modulus: i64

shift: i64

divisor: u64

Unknown

Not a recognized fill shape (data is external to the compiler).

Implementations

impl Fill

pub fn float_sets(&self) -> Option<(f64, Vec<(usize, f64)>)>

The float element overrides of a float fill, as values.

pub fn element(&self, p: i64) -> Option<Scalar>

Element p of a fill that is the same at every length — None for an override list, whose length the fill does not carry past its last override, and for data the compiler cannot see.

Trait Implementations

impl Clone for Fill

fn clone(&self) -> Fill

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Fill

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Fill

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Hash for Fill

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 PartialEq for Fill

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

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for Fill

impl StructuralPartialEq for Fill