Struct Program 

pub struct Program {
    pub stmts: Vec<Expr>,
    pub params: Vec<ParamSpec>,
    pub display_src: String,
    pub agreement: Agreement,
    pub fmt: FmtOpts,
    pub rules: Rules,
}

A compiled program: immutable, reusable, holds no data bindings.

Fields

stmts: Vec<Expr>

params: Vec<ParamSpec>

display_src: String

The source as the user would recognise it (interpolations shown as {name}); all spans point into this string.

agreement: Agreement

fmt: FmtOpts

rules: Rules

The dialect this program was compiled under, resolved.

Implementations

impl Program

pub fn run( &self, args: &[Array], out: &mut dyn FnMut(&str), ) -> Result<Option<Array>>

Execute with one value per parameter, in params order. Returns None when the last sentence yields no value.

pub fn run_on( &self, device: &Device, args: &[Array], out: &mut dyn FnMut(&str), ) -> Result<Option<Array>>

Execute with the fused kernels placed on device.

Placement is not binding: the program, its data and its diagnostics are the same whatever device is named here. What a device will not take runs on the CPU, and explain says which and why.

pub fn render_error(&self, e: &Error) -> String

pub fn explain(&self, args: Option<&[Array]>) -> String

What this expression became, as text: one section per sentence, giving the structure the frontend and the fusion pass produced.

With one value per parameter (or none, for a program that takes none) the program is also run, and every node is annotated with the shape and dtype it produced — a fused node with whether its kernel ran, and why not when it did not. The run is the ordinary one, so it has the ordinary effects; output it makes is discarded here, and an error stops the annotations and is reported at the end.

pub fn explain_on(&self, device: &Device, args: Option<&[Array]>) -> String

Program::explain, with the run placed on device: every fused node then also says where its arithmetic happened, and why it was not the device when it was not.

Trait Implementations

impl Clone for Program

fn clone(&self) -> Program

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Program

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

Formats the value using the given formatter.