Enum Instruction 

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

A Quil instruction.

Each variant (for Python users, each nested subclass) corresponds to a possible type of Quil instruction, which is accessible as a member within the variant.

Python Users

The subclasses of this class are class attributes defined on it, and can be used to “wrap” instructions when they should be stored together. In particular, they are NOT the instruction classes you’d typically create, and instances of instruction classes are NOT subclasses of this class:

>>> from quil.instructions import Instruction, Gate, Qubit
>>> issubclass(Instruction.Gate, Instruction)
True
>>> issubclass(Gate, Instruction)
False
>>> g = Gate("X", (), (Qubit.Fixed(0),), ())
>>> isinstance(g, Gate)
True
>>> isinstance(g, Instruction.Gate)
False
>>> g_instr = Instruction.Gate(g)
>>> isinstance(g_instr, Gate)
False
>>> isinstance(g_instr, Instruction.Gate)
True
>>> isinstance(g_instr._0, Gate)
True
>>> g_instr._0 == g
True

The point of this class is to wrap different kinds of instructions when stored together in a collection, all of which are of type Instruction. You can check for different instruction variants and destructure them using match:

match g_instr:
    case Instruction.Gate(gate):
        assert isinstance(gate, Gate)
    case Instruction.Wait() | Instruction.Nop():
        # note the `()` -- these aren't like Python's enumerations!

Variants

Arithmetic(Arithmetic)

BinaryLogic(BinaryLogic)

CalibrationDefinition(CalibrationDefinition)

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 is_quil_t(&self) -> bool

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

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

Trait Implementations

impl Clone for Instruction

fn clone(&self) -> Instruction

Returns a duplicate 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 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

Equality operator ==.

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

Inequality operator !=.

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