Enum quil_rs::instruction::Instruction

pub enum Instruction {
    Arithmetic(Arithmetic),
    BinaryLogic(BinaryLogic),
    CalibrationDefinition(Calibration),
    Capture(Capture),
    CircuitDefinition(CircuitDefinition),
    Convert(Convert),
    Comparison(Comparison),
    Declaration(Declaration),
    Delay(Delay),
    Exchange(Exchange),
    Fence(Fence),
    FrameDefinition(FrameDefinition),
    Gate(Gate),
    GateDefinition(GateDefinition),
    Halt,
    Include(Include),
    Jump(Jump),
    JumpUnless(JumpUnless),
    JumpWhen(JumpWhen),
    Label(Label),
    Load(Load),
    MeasureCalibrationDefinition(MeasureCalibrationDefinition),
    Measurement(Measurement),
    Move(Move),
    Nop,
    Pragma(Pragma),
    Pulse(Pulse),
    RawCapture(RawCapture),
    Reset(Reset),
    SetFrequency(SetFrequency),
    SetPhase(SetPhase),
    SetScale(SetScale),
    ShiftFrequency(ShiftFrequency),
    ShiftPhase(ShiftPhase),
    Store(Store),
    SwapPhases(SwapPhases),
    UnaryLogic(UnaryLogic),
    WaveformDefinition(WaveformDefinition),
    Wait,
}

Variants

Arithmetic(Arithmetic)

BinaryLogic(BinaryLogic)

CalibrationDefinition(Calibration)

Capture(Capture)

CircuitDefinition(CircuitDefinition)

Convert(Convert)

Comparison(Comparison)

Declaration(Declaration)

Delay(Delay)

Exchange(Exchange)

Fence(Fence)

FrameDefinition(FrameDefinition)

Gate(Gate)

GateDefinition(GateDefinition)

Halt

Include(Include)

Jump(Jump)

JumpUnless(JumpUnless)

JumpWhen(JumpWhen)

Label(Label)

Load(Load)

MeasureCalibrationDefinition(MeasureCalibrationDefinition)

Measurement(Measurement)

Move(Move)

Nop

Pragma(Pragma)

Pulse(Pulse)

RawCapture(RawCapture)

Reset(Reset)

SetFrequency(SetFrequency)

SetPhase(SetPhase)

SetScale(SetScale)

ShiftFrequency(ShiftFrequency)

ShiftPhase(ShiftPhase)

Store(Store)

SwapPhases(SwapPhases)

UnaryLogic(UnaryLogic)

WaveformDefinition(WaveformDefinition)

Wait

Implementations

impl Instruction

pub fn apply_to_expressions(&mut self, closure: impl FnMut(&mut Expression))

Apply the provided closure to this instruction, mutating any Expressions within. Does not affect instructions without Expressions within. Does not traverse or mutate instructions nested within blocks (such as within DEFCAL).

Example

use std::mem::replace;
use std::str::FromStr;
use quil_rs::{expression::Expression, Program};


let program = Program::from_str("SHIFT-PHASE 0 \"rf\" 2*2").unwrap();
let mut instructions = program.to_instructions();
instructions.iter_mut().for_each(|inst| inst.apply_to_expressions(Expression::simplify));

assert_eq!(instructions[0].to_string(), String::from("SHIFT-PHASE 0 \"rf\" 4"))

pub fn is_scheduled(&self) -> bool

Per the Quil-T spec, whether this instruction’s timing within the pulse program must be precisely controlled so as to begin exactly on the end of the latest preceding timed instruction

impl Instruction

pub fn get_memory_accesses(&self) -> MemoryAccesses

Return all memory accesses by the instruction - in expressions, captures, and memory manipulation

Trait Implementations

impl Clone for Instruction

fn clone(&self) -> Instruction

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Instruction

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

Formats the value using the given formatter.

impl Display for Instruction

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

Formats the value using the given formatter.

impl From<&Instruction> for InstructionRole

fn from(instruction: &Instruction) -> Self

Converts to this type from the input type.

impl PartialEq<Instruction> for Instruction

fn eq(&self, other: &Instruction) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for Instruction