Struct CircuitBuilder 

pub struct CircuitBuilder<'a, T>
where
    T: ?Sized,
{ /* private fields */ }

Builder to build regions of dataflow graphs that look like Circuits, where some inputs of operations directly correspond to some outputs.

Allows appending operations by indexing a vector of input wires.

Implementations

impl<'a, T> CircuitBuilder<'a, T>

where T: Dataflow + ?Sized,

pub fn new( wires: impl IntoIterator<Item = Wire>, builder: &'a mut T, ) -> CircuitBuilder<'a, T>

Construct a new CircuitBuilder from a vector of incoming wires and the builder for the graph.

pub fn n_wires(&self) -> usize

Returns the number of wires tracked.

pub fn tracked_wire(&self, index: usize) -> Option<Wire>

Returns the wire associated with the given index.

pub fn tracked_units(&self) -> impl Iterator<Item = usize>

Returns an iterator over the tracked linear units.

pub fn tracked_units_arr<const N: usize>(&self) -> [usize; N]

Returns an array with the tracked linear units.

Panics

If the number of outputs does not match N.

pub fn append( &mut self, op: impl Into<OpType>, indices: impl IntoIterator<Item = usize> + Clone, ) -> Result<&mut CircuitBuilder<'a, T>, BuildError>

Append an op to the wires in the inner vector with given indices. The outputs of the operation become the new wires at those indices. Only valid for operations that have the same input type row as output type row. Returns a handle to self to allow chaining.

pub fn append_and_consume<A>( &mut self, op: impl Into<OpType>, inputs: impl IntoIterator<Item = A>, ) -> Result<&mut CircuitBuilder<'a, T>, BuildError>

where A: Into<CircuitUnit>,

The same as CircuitBuilder::append_with_outputs except it assumes no outputs and instead returns a reference to self to allow chaining.

pub fn append_with_outputs<A>( &mut self, op: impl Into<OpType>, inputs: impl IntoIterator<Item = A>, ) -> Result<Vec<Wire>, BuildError>

where A: Into<CircuitUnit>,

Append an op with some inputs being the stored wires. Any inputs of the form CircuitUnit::Linear are used to index the stored wires. The outputs at those indices are used to replace the stored wire. The remaining outputs are returned.

Errors

Returns an error on an invalid input unit.

pub fn append_with_outputs_arr<const N: usize, A>( &mut self, op: impl Into<OpType>, inputs: impl IntoIterator<Item = A>, ) -> Result<[Wire; N], BuildError>

where A: Into<CircuitUnit>,

Append an op with some inputs being the stored wires. Any inputs of the form CircuitUnit::Linear are used to index the stored wires. The outputs at those indices are used to replace the stored wire. The remaining outputs are returned as an array.

Errors

Returns an error on an invalid input unit.

Panics

If the number of outputs does not match N.

pub fn add_constant(&mut self, value: impl Into<Value>) -> Wire

Adds a constant value to the circuit and loads it into a wire.

pub fn track_wire(&mut self, wire: Wire) -> usize

Add a wire to the list of tracked wires.

Returns the new unit index.

pub fn untrack_wire(&mut self, index: usize) -> Result<Wire, CircuitBuildError>

Stops tracking a linear unit, and returns the last wire corresponding to it.

Returns the new unit index.

Errors

Returns a CircuitBuildError::InvalidWireIndex if the index is invalid.

pub fn finish(self) -> Vec<Wire>

Finish building the circuit region and return the dangling wires that correspond to the initially provided wires.

Trait Implementations

impl<'a, T> Debug for CircuitBuilder<'a, T>

where T: Debug + ?Sized,

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

Formats the value using the given formatter.

impl<'a, T> PartialEq for CircuitBuilder<'a, T>

where T: PartialEq + ?Sized,

fn eq(&self, other: &CircuitBuilder<'a, T>) -> 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, T> StructuralPartialEq for CircuitBuilder<'a, T>

where T: ?Sized,