Macro qip::wrap_fn

macro_rules! wrap_fn {
    (@ names() <- $name : ident) => { ... };
    (@ names($($body : tt) *) <- $name : ident) => { ... };
    (@ names($($body : tt) *) <- $name : ident, $($tail : tt) *) => { ... };
    (@ invoke($func : expr, $builder : expr) ($($body : tt) *) <- $name : ident) => { ... };
    (@ invoke($func : expr, $builder : expr) ($($body : tt) *) <- $name : ident,
 $($tail : tt) *) => { ... };
    (@ unwrap_regs($func : expr, $rs : ident) $name : ident) => { ... };
    (@ unwrap_regs($func : expr, $rs : ident) $name : ident, $($tail : tt) *) => { ... };
    (@ result_body($builder : expr, $func : expr, $rs : ident, $arg : ident)
 $($tail : tt) *) => { ... };
    (@ raw_body($builder : expr, $func : expr, $rs : ident, $arg : ident)
 $($tail : tt) *) => { ... };
    (@ result_body($builder : expr, $func : expr, $rs : ident) $($tail : tt) *) => { ... };
    (@ raw_body($builder : expr, $func : expr, $rs : ident) $($tail : tt) *) => { ... };
    (pub $newfunc : ident [$($typetail : tt) *] ($arg : ident : $argtype : ident),
 ($func : expr), $($tail : tt) *) => { ... };
    (pub $newfunc : ident [$($typetail : tt) *] ($arg : ident : $argtype : ident),
 $func : expr, $($tail : tt) *) => { ... };
    ($newfunc : ident [$($typetail : tt) *] ($arg : ident : $argtype : ident),
 ($func : expr), $($tail : tt) *) => { ... };
    ($newfunc : ident [$($typetail : tt) *] ($arg : ident : $argtype : ident),
 $func : expr, $($tail : tt) *) => { ... };
    (pub $newfunc : ident($arg : ident : $argtype : ident), ($func : expr),
 $($tail : tt) *) => { ... };
    (pub $newfunc : ident($arg : ident : $argtype : ident), $func : expr,
 $($tail : tt) *) => { ... };
    ($newfunc : ident($arg : ident : $argtype : ident), ($func : expr),
 $($tail : tt) *) => { ... };
    ($newfunc : ident($arg : ident : $argtype : ident), $func : expr,
 $($tail : tt) *) => { ... };
    (pub $newfunc : ident, ($func : expr), $($tail : tt) *) => { ... };
    (pub $newfunc : ident, $func : expr, $($tail : tt) *) => { ... };
    ($newfunc : ident, ($func : expr), $($tail : tt) *) => { ... };
    ($newfunc : ident, $func : expr, $($tail : tt) *) => { ... };
}

Allows the wrapping of a function with signature: Fn(&mut dyn UnitaryBuilder, Register, Register, ...) -> (Register, ...) or Fn(&mut dyn UnitaryBuilder, Register, Register, ...) -> Result<(Register, ...), CircuitError> to make a new function with signature: Fn(&mut dyn UnitaryBuilder, Vec<Register>) -> Result<Vec<Register>, CircuitError> and is therefore compatible with program!.

Example

use qip::*;

let n = 3;
let mut b = OpBuilder::new();
let ra = b.register(n)?;
let rb = b.register(n)?;

fn gamma(b: &mut dyn UnitaryBuilder, ra: Register, rb: Register) -> (Register, Register) {
    let (ra, rb) = b.cnot(ra, rb);
    (ra, rb)
}

wrap_fn!(wrapped_gamma, gamma, ra, rb);

// Gamma |ra>|rb[2]>
// Gamma |ra[0]>|rb>
let (ra, rb) = program!(&mut b, ra, rb;
    wrapped_gamma ra, rb[2];
    wrapped_gamma ra[0], rb;
)?;
let r = b.merge(vec![ra, rb])?;

Example with Result

use qip::*;

let n = 3;
let mut b = OpBuilder::new();
let ra = b.register(n)?;
let rb = b.register(n)?;

fn gamma(b: &mut dyn UnitaryBuilder, ra: Register, rb: Register) -> Result<(Register, Register), CircuitError> {
    let (ra, rb) = b.cnot(ra, rb);
    Ok((ra, rb))
}

wrap_fn!(wrapped_gamma, (gamma), ra, rb);

// Gamma |ra>|rb[2]>
// Gamma |ra[0]>|rb>
let (ra, rb) = program!(&mut b, ra, rb;
    wrapped_gamma ra, rb[2];
    wrapped_gamma ra[0], rb;
)?;
let r = b.merge(vec![ra, rb])?;

Example with UnitaryBuilder function

use qip::*;

let n = 3;
let mut b = OpBuilder::new();
let ra = b.register(n)?;
let rb = b.register(n)?;

wrap_fn!(cnot, UnitaryBuilder::cnot, ra, rb);

// cnot |ra>|rb[2]>
// cnot |ra[0]>|rb>
let (ra, rb) = program!(&mut b, ra, rb;
    cnot ra, rb[2];
    cnot ra[0], rb;
)?;
let r = b.merge(vec![ra, rb])?;