Rust by Example

// Call `find_min!` on the tail `$y`

std::cmp::min($x, find_min!($($y),+))

)

}

fn main() {

println!("{}", find_min!(1u32));

println!("{}", find_min!(1u32 + 2, 2u32));

println!("{}", find_min!(5u32, 2u32 * 3, 4u32));

}

הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה

XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

DRY (Don't Repeat Yourself)

Macros allow writing DRY code by factoring out the common parts of functions and/or test suites. Here is an example that implements and tests the +=, *= and -= operators on Vec:

use std::ops::{Add, Mul, Sub};

macro_rules! assert_equal_len {

// The `tt` (token tree) designator is used for

// operators and tokens.

($a:expr, $b:expr, $func:ident, $op:tt) => {

assert!($a.len() == $b.len(),

"{:?}: dimension mismatch: {:?} {:?} {:?}",

stringify!($func),

($a.len(),),

stringify!($op),

($b.len(),));

};

}

macro_rules! op {

($func:ident, $bound:ident, $op:tt, $method:ident) => {

fn $func + Copy>(xs: &mut Vec, ys: &Vec) {

assert_equal_len!(xs, ys, $func, $op);

for (x, y) in xs.iter_mut().zip(ys.iter()) {

*x = $bound::$method(*x, *y);

// *x = x.$method(*y);

}

}

};

}

// Implement `add_assign`, `mul_assign`, and `sub_assign` functions.

op!(add_assign, Add, +=, add);

op!(mul_assign, Mul, *=, mul);

op!(sub_assign, Sub, -=, sub);

mod test {

use std::iter;

macro_rules! test {

($func:ident, $x:expr, $y:expr, $z:expr) => {

#[test]

fn $func() {

for size in 0usize..10 {

let mut x: Vec<_> = iter::repeat($x).take(size).collect();

let y: Vec<_> = iter::repeat($y).take(size).collect();

let z: Vec<_> = iter::repeat($z).take(size).collect();

super::$func(&mut x, &y);

assert_eq!(x, z);

}

}

};

}

// Test `add_assign`, `mul_assign`, and `sub_assign`.

test!(add_assign, 1u32, 2u32, 3u32);

test!(mul_assign, 2u32, 3u32, 6u32);

test!(sub_assign, 3u32, 2u32, 1u32);

}

הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה