find_max.rs

#![crate_name="find_max"]
//! Test various syntaxes to find the maximum value of a vector using generic function.
//!
//! @license MIT license <http://www.opensource.org/licenses/mit-license.php>

/**
 * Code from Rust MeetUp (March, 31st 2014) at Mozilla Space, Paris.
 * https://reps.mozilla.org/e/meetup-rust-paris-02/
 */
fn find_max1<'a, T: Ord>(lst: &'a Vec<T>) -> Option<&'a T> {
	let mut max = None;

	for i in lst.iter() {
		max = match max {
			None => Some(i),
			Some(ref m) if i > *m => Some(i),
			_ => max
		}
	}
	max
}

/**
 * Using a closure.
 *
 * Inspired by tutorial "15 Closure"
 * http://doc.rust-lang.org/tutorial.html#closures
 */
fn find_max2<'a, T: Ord>(lst: &'a Vec<T>) -> Option<&'a T> {
	let mut max = None;

	// huon said:
	// place the closure and the loop into its own scope
	// to constrain the borrow from the closure.
	// (to be able to modify `max` it has to take an `&mut` borrow to it)
	{
		let mut find_max = |i: &'a T| {
			max = match max {
				None => Some(i),
				Some(ref m) if i > *m => Some(i),
				_ => max
			}
		};
		for x in lst.iter() {
			find_max(x);
		}
	}

	max
}

/**
 * Using a closure and .map().
 */
fn find_max3<'a, T: Ord>(lst: &'a Vec<T>) -> Option<&'a T> {
	let mut max = None;

	let find_max = |i: &'a T| {
		max = match max {
			None => Some(i),
			Some(ref m) if i > *m => Some(i),
			_ => max
		};
		max
	};
	lst.iter().map(find_max).last().unwrap()
}

/**
 * Using std lib
 */
#[cfg(feature = "nightly")]
fn find_maxstd<'a, T: Ord>(lst: &'a Vec<T>) -> Option<&'a T> {
    lst.iter().max_by(|x| *x)
}

#[test]
fn test_find_max1() {
	let v = vec!(0i32, 1, 2, 3, 4, 5, 6, 7, 8, 9);
	let nine = 9i32;
	assert_eq!(Some(&nine), find_max1(&v));
}

#[test]
fn test_find_max2() {
	let v = vec!(0i32, 1, 2, 3, 4, 5, 6, 7, 8, 9);
	let nine = 9i32;
	assert_eq!(Some(&nine), find_max2(&v));
}

#[test]
fn test_find_max3() {
	let v = vec!(0i32, 1, 2, 3, 4, 5, 6, 7, 8, 9);
	let nine = 9i32;
	assert_eq!(Some(&nine), find_max3(&v));
}

#[test]
#[cfg(feature = "nightly")]
fn test_find_maxstd() {
	let v = vec!(0i32, 1, 2, 3, 4, 5, 6, 7, 8, 9);
	let nine = 9i32;
	assert_eq!(Some(&nine), find_maxstd(&v));
}

#[cfg(feature = "nightly")]
#[cfg(test)]
mod bench {
    extern crate test;
    use test::Bencher;

    #[bench]
    fn bench_find_max1(b: &mut Bencher) {
        let v = vec!(0i32, 1, 2, 3, 4, 5, 6, 7, 8, 9);
        b.iter(|| {
            find_max1(&v);
        });
    }

    #[bench]
    fn bench_find_max2(b: &mut Bencher) {
        let v = vec!(0i32, 1, 2, 3, 4, 5, 6, 7, 8, 9);
        b.iter(|| {
            find_max2(&v);
        });
    }

    #[bench]
    fn bench_find_max3(b: &mut Bencher) {
        let v = vec!(0i32, 1, 2, 3, 4, 5, 6, 7, 8, 9);
        b.iter(|| {
            find_max3(&v);
        });
    }
}

#[cfg(not(test))]
fn main () {
	let int_v = vec!(5i32, 2, 0, 8, 2);
	println!("find_max1 -> {:?}", find_max1(&int_v));
	println!("find_max2 -> {:?}", find_max2(&int_v));
	println!("find_max3 -> {:?}", find_max3(&int_v));
	let v = vec!("qehgesrhsetha", "bqthst", "cthersth");
	let b = find_max3(&v);
	println!("{:?}", b);

	println!("{:?}", v);
	println!("{:?}", b);
}