feat: add Program::to_latex

quil-rs/src/expression/mod.rs

@@ -1009,8 +1009,8 @@ mod tests {
     #[test]
     fn specific_round_trip_tests() {
         for input in &[
-            "-1*(phases[0]+phases[1])",
-            "(-1*(phases[0]+phases[1]))+(-1*(phases[0]+phases[1]))",
+            "-1*(phases+phases[1])",
+            "(-1*(phases+phases[1]))+(-1*(phases+phases[1]))",
         ] {
             let parsed = Expression::from_str(input);
             let parsed = parsed.unwrap();

quil-rs/src/instruction/declaration.rs

@@ -201,6 +201,11 @@ impl Quil for MemoryReference {
         f: &mut impl std::fmt::Write,
         _fall_back_to_debug: bool,
     ) -> crate::quil::ToQuilResult<()> {
+        if self.index == 0 {
+            write!(f, "{}", self.name)?;
+            return Ok(());
+        }
+
         write!(f, "{}[{}]", self.name, self.index).map_err(Into::into)
     }
 }

quil-rs/src/instruction/gate.rs

@@ -2,18 +2,22 @@ use crate::{
     expression::Expression,
     imag,
     instruction::{write_expression_parameter_string, write_parameter_string, write_qubits, Qubit},
+    parser::{gate::parse_gate, lex, ParseError},
+    program::{disallow_leftover, SyntaxError},
     quil::{write_join_quil, Quil},
     real,
     validation::identifier::{
         validate_identifier, validate_user_identifier, IdentifierValidationError,
     },
 };
 use ndarray::{array, linalg::kron, Array2};
+use nom_locate::LocatedSpan;
 use num_complex::Complex64;
 use once_cell::sync::Lazy;
 use std::{
     cmp::Ordering,
     collections::{HashMap, HashSet},
+    str::FromStr,
 };
 
 /// A struct encapsulating all the properties of a Quil Quantum Gate.
@@ -176,6 +180,16 @@ impl Gate {
     }
 }
 
+impl FromStr for Gate {
+    type Err = SyntaxError<Self>;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let input = LocatedSpan::new(s);
+        let tokens = lex(input)?;
+        disallow_leftover(parse_gate(&tokens).map_err(ParseError::from_nom_internal_err))
+    }
+}
+
 /// Lift a unitary matrix to act on the specified qubits in a full `n_qubits`-qubit Hilbert
 /// space.
 ///

quil-rs/src/lib.rs

@@ -31,6 +31,7 @@
 //! [constructor for timing graphs]: crate::program::graph::ScheduledProgram#method.get_dot_format
 //! [expressions]: crate::expression::Expression
 //! [instructions]: crate::instruction::Instruction
+//! [latex]: crate::program::latex::Latex#method.to_latex
 //! [parser]: crate::program::Program#method.from_str
 //! [programs]: crate::program::Program
 //! [serializer]: crate::program::Program#method.to_string

quil-rs/src/parser/expression.rs

@@ -284,7 +284,8 @@ mod tests {
             "%theta",
             "cis(%theta)",
             "%a+%b",
-            "(pi/2)+(1*theta[0])",
+            "(pi/2)+(1*theta)",
+            "(pi/2)+(1*theta[1])",
             "3 - -2",
         ];
 

quil-rs/src/parser/gate.rs

@@ -14,7 +14,7 @@
 
 use nom::{combinator::opt, multi::many0, multi::separated_list0, sequence::delimited};
 
-use crate::{instruction::Instruction, token};
+use crate::token;
 
 use super::{
     common::{self, parse_gate_modifier},
@@ -25,7 +25,7 @@ use crate::instruction::Gate;
 use crate::parser::InternalParserResult;
 
 /// Parse a gate instruction.
-pub(crate) fn parse_gate<'a>(input: ParserInput<'a>) -> InternalParserResult<'a, Instruction> {
+pub(crate) fn parse_gate<'a>(input: ParserInput<'a>) -> InternalParserResult<'a, Gate> {
     let (input, modifiers) = many0(parse_gate_modifier)(input)?;
     let (input, name) = token!(Identifier(v))(input)?;
     let (input, parameters) = opt(delimited(
@@ -37,32 +37,32 @@ pub(crate) fn parse_gate<'a>(input: ParserInput<'a>) -> InternalParserResult<'a,
     let (input, qubits) = many0(common::parse_qubit)(input)?;
     Ok((
         input,
-        Instruction::Gate(Gate {
+        Gate {
             name,
             parameters,
             qubits,
             modifiers,
-        }),
+        },
     ))
 }
 
 #[cfg(test)]
 mod test {
     use super::parse_gate;
     use crate::expression::Expression;
-    use crate::instruction::{Gate, GateModifier, Instruction, Qubit};
+    use crate::instruction::{Gate, GateModifier, Qubit};
     use crate::make_test;
     use crate::parser::lexer::lex;
 
     make_test!(
         test_modifiers,
         parse_gate,
         "DAGGER CONTROLLED RX(pi) 0 1",
-        Instruction::Gate(Gate {
+        Gate {
             name: "RX".to_string(),
             parameters: vec![Expression::PiConstant],
             qubits: vec![Qubit::Fixed(0), Qubit::Fixed(1)],
             modifiers: vec![GateModifier::Dagger, GateModifier::Controlled],
-        })
+        }
     );
 }

quil-rs/src/parser/instruction.rs

@@ -13,7 +13,7 @@
 // limitations under the License.
 
 use nom::{
-    combinator::all_consuming,
+    combinator::{all_consuming, map},
     multi::{many0, many1},
     sequence::{delimited, preceded},
 };
@@ -113,7 +113,9 @@ pub(crate) fn parse_instruction(input: ParserInput) -> InternalParserResult<Inst
             },
             _ => todo!(),
         },
-        Some((Token::Identifier(_), _)) | Some((Token::Modifier(_), _)) => gate::parse_gate(input),
+        Some((Token::Identifier(_), _)) | Some((Token::Modifier(_), _)) => {
+            map(gate::parse_gate, Instruction::Gate)(input)
+        }
         Some((_, _)) => Err(nom::Err::Failure(InternalParseError::from_kind(
             &input[..1],
             ParserErrorKind::NotACommandOrGate,

quil-rs/src/parser/mod.rs

@@ -19,7 +19,7 @@ pub(crate) use instruction::parse_instructions;
 pub(crate) use lexer::lex;
 
 mod command;
-mod gate;
+pub(crate) mod gate;
 mod macros;
 
 pub(crate) mod common;