Enum Instruction

pub enum Instruction {
    Arithmetic(Arithmetic),
    BinaryLogic(BinaryLogic),
    CalibrationDefinition(Calibration),
    Call(Call),
    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)

Call(Call)

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, quil::Quil};


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_quil().unwrap(), String::from("SHIFT-PHASE 0 \"rf\" 4"))

pub fn get_qubits(&self) -> Vec<&Qubit>

Return immutable references to the Qubits contained within an instruction

pub fn get_qubits_mut(&mut self) -> Vec<&mut Qubit>

Return mutable references to the Qubits contained within an instruction

pub fn is_quil_t(&self) -> bool

Returns true if the instruction is a Quil-T instruction.

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, extern_signature_map: &ExternSignatureMap, ) -> MemoryAccessesResult

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

This will fail if the program contains Instruction::Call instructions that cannot be resolved against a signature in the provided ExternSignatureMap (either because they call functions that don’t appear in the map or because the types of the parameters are wrong).

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 From<&Instruction> for InstructionRole

fn from(instruction: &Instruction) -> Self

Converts to this type from the input type.

impl FromStr for Instruction

type Err = ParseInstructionError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl PartialEq for Instruction

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

fn write( &self, f: &mut impl Write, fall_back_to_debug: bool, ) -> Result<(), ToQuilError>

Write the Quil representation of the item to the given writer. If fall_back_to_debug is true, then it must not return an error.

fn to_quil(&self) -> Result<String, ToQuilError>

Return a string in valid Quil syntax or an error if the item cannot be represented with valid Quil.

fn to_quil_or_debug(&self) -> String

Return a string in valid Quil syntax if possible. Any individual component of this object which cannot be represented in Quil will be replaced with a Debug representation of that component.

impl StructuralPartialEq for Instruction