Advertisement
Not a member of Pastebin yet?
Sign Up,
it unlocks many cool features!
- #![allow(non_snake_case)]
- #![feature(test)]
- extern crate test;
- use std::iter::FromIterator;
- #[cfg(test)]
- use test::Bencher;
- #[derive(Copy, Clone, PartialEq, Eq, Debug)]
- struct LastOne<T>(Option<T>);
- impl<T> FromIterator<T> for LastOne<T> {
- #[inline]
- fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> LastOne<T> {
- LastOne(iter.into_iter().last())
- }
- }
- type Last<T> = LastOne<T>;
- impl<T> Last<T> {
- fn new(x: T) -> Last<T> { LastOne(Some(x)) }
- }
- fn from_iter_baseline<C, T, E, I>(iter: I) -> Result<C, E>
- where I: Iterator<Item = Result<T, E>>,
- C: FromIterator<T>,
- {
- FromIterator::from_iter(iter)
- }
- fn from_iter_adapter<C, T, E, I>(iter: I) -> Result<C, E>
- where I: Iterator<Item = Result<T, E>>,
- C: FromIterator<T>,
- {
- struct Adapter<Iter, E> {
- iter: Iter,
- err: Option<E>,
- }
- impl<T, E, Iter: Iterator<Item=Result<T, E>>> Iterator for Adapter<Iter, E> {
- type Item = T;
- #[inline]
- fn next(&mut self) -> Option<T> {
- match self.iter.next() {
- Some(Ok(value)) => Some(value),
- Some(Err(err)) => {
- self.err = Some(err);
- None
- }
- None => None,
- }
- }
- fn size_hint(&self) -> (usize, Option<usize>) {
- let (_min, max) = self.iter.size_hint();
- (0, max)
- }
- }
- let mut adapter = Adapter { iter, err: None };
- let v: C = FromIterator::from_iter(adapter.by_ref());
- match adapter.err {
- Some(err) => Err(err),
- None => Ok(v),
- }
- }
- fn from_iter_with_scan_with_freevar<C, T, E, I>(iter: I) -> Result<C, E>
- where I: Iterator<Item = Result<T, E>>,
- C: FromIterator<T>,
- {
- let mut err = None;
- let v = {
- let adapter = iter.scan((), |_, item| {
- match item {
- Ok(x) => Some(x),
- Err(x) => {
- err = Some(x);
- None
- },
- }
- });
- FromIterator::from_iter(adapter)
- };
- match err {
- Some(err) => Err(err),
- None => Ok(v),
- }
- }
- fn from_iter_with_scan_passing_state<C, T, E, I>(iter: I) -> Result<C, E>
- where I: Iterator<Item = Result<T, E>>,
- C: FromIterator<T>,
- {
- let mut err = None;
- let v = {
- let adapter = iter.scan(&mut err, |err, item| {
- match item {
- Ok(x) => Some(x),
- Err(x) => {
- **err = Some(x);
- None
- },
- }
- });
- FromIterator::from_iter(adapter)
- };
- match err {
- Some(err) => Err(err),
- None => Ok(v),
- }
- }
- fn from_iter_with_filter_map<C, T, E, I>(iter: I) -> Result<C, E>
- where I: Iterator<Item = Result<T, E>>,
- C: FromIterator<T>,
- {
- let mut err = None;
- let v = {
- let adapter = iter.filter_map(|item| {
- match item {
- Ok(x) => Some(x),
- Err(x) => {
- err = Some(x);
- None
- },
- }
- });
- FromIterator::from_iter(adapter)
- };
- match err {
- Some(err) => Err(err),
- None => Ok(v),
- }
- }
- fn main() {
- let one_a: Result<Last<u8>, _> = from_iter_baseline("1,2,3".split(",").map(|x| x.parse()));
- let one_b: Result<Last<u8>, _> = from_iter_adapter("1,2,3".split(",").map(|x| x.parse()));
- let two_a: Result<Last<u8>, _> = from_iter_with_scan_passing_state("1,2,3".split(",").map(|x| x.parse()));
- let two_b: Result<Last<u8>, _> = from_iter_with_scan_with_freevar("1,2,3".split(",").map(|x| x.parse()));
- let three: Result<Last<u8>, _> = from_iter_with_filter_map("1,2,3".split(",").map(|x| x.parse()));
- println!("{:?}", one_a);
- println!("{:?}", one_b);
- println!("{:?}", two_a);
- println!("{:?}", two_b);
- println!("{:?}", three);
- let one_a: Result<Last<u8>, _> = from_iter_baseline("1,a,3".split(",").map(|x| x.parse()));
- let one_b: Result<Last<u8>, _> = from_iter_adapter("1,a,3".split(",").map(|x| x.parse()));
- let two_a: Result<Last<u8>, _> = from_iter_with_scan_passing_state("1,a,3".split(",").map(|x| x.parse()));
- let two_b: Result<Last<u8>, _> = from_iter_with_scan_with_freevar("1,a,3".split(",").map(|x| x.parse()));
- let three: Result<Last<u8>, _> = from_iter_with_filter_map("1,a,3".split(",").map(|x| x.parse()));
- println!("{:?}", one_a);
- println!("{:?}", one_b);
- println!("{:?}", two_a);
- println!("{:?}", two_b);
- println!("{:?}", three);
- }
- #[bench]
- fn bench__vec_from_iter_using_baseline___(b: &mut Bencher) {
- let expected = vec![1; 1000];
- let v: Vec<Result<isize, String>> = vec![Ok(1); 1000];
- b.iter(|| {
- let result: Result<Vec<isize>, String> = from_iter_baseline(v.iter().cloned());
- assert_eq!(result.unwrap(), expected);
- });
- }
- #[bench]
- fn bench__vec_from_iter_using_adapter____(b: &mut Bencher) {
- let expected = vec![1; 1000];
- let v: Vec<Result<isize, String>> = vec![Ok(1); 1000];
- b.iter(|| {
- let result: Result<Vec<isize>, String> = from_iter_adapter(v.iter().cloned());
- assert_eq!(result.unwrap(), expected);
- });
- }
- #[bench]
- fn bench__vec_from_iter_with_scan_param__(b: &mut Bencher) {
- let expected = vec![1; 1000];
- let v: Vec<Result<isize, String>> = vec![Ok(1); 1000];
- b.iter(|| {
- let result: Result<Vec<isize>, String> = from_iter_with_scan_passing_state(v.iter().cloned());
- assert_eq!(result.unwrap(), expected);
- });
- }
- #[bench]
- fn bench__vec_from_iter_with_scan_freevar(b: &mut Bencher) {
- let expected = vec![1; 1000];
- let v: Vec<Result<isize, String>> = vec![Ok(1); 1000];
- b.iter(|| {
- let result: Result<Vec<isize>, String> = from_iter_with_scan_with_freevar(v.iter().cloned());
- assert_eq!(result.unwrap(), expected);
- });
- }
- #[bench]
- fn bench__vec_from_iter_with_filter_map__(b: &mut Bencher) {
- let expected = vec![1; 1000];
- let v: Vec<Result<isize, String>> = vec![Ok(1); 1000];
- b.iter(|| {
- let result: Result<Vec<isize>, String> = from_iter_with_filter_map(v.iter().cloned());
- assert_eq!(result.unwrap(), expected);
- });
- }
- #[bench]
- fn bench_last_from_iter_using_baseline___(b: &mut Bencher) {
- let expected = Last::new(1);
- let v: Vec<Result<isize, String>> = vec![Ok(1); 3000];
- b.iter(|| {
- let result: Result<Last<isize>, String> = from_iter_baseline(v.iter().cloned());
- assert_eq!(result.unwrap(), expected);
- });
- }
- #[bench]
- fn bench_last_from_iter_using_adapter____(b: &mut Bencher) {
- let expected = Last::new(1);
- let v: Vec<Result<isize, String>> = vec![Ok(1); 3000];
- b.iter(|| {
- let result: Result<Last<isize>, String> = from_iter_adapter(v.iter().cloned());
- assert_eq!(result.unwrap(), expected);
- });
- }
- #[bench]
- fn bench_last_from_iter_with_scan_param__(b: &mut Bencher) {
- let expected = Last::new(1);
- let v: Vec<Result<isize, String>> = vec![Ok(1); 3000];
- b.iter(|| {
- let result: Result<Last<isize>, String> = from_iter_with_scan_passing_state(v.iter().cloned());
- assert_eq!(result.unwrap(), expected);
- });
- }
- #[bench]
- fn bench_last_from_iter_with_scan_freevar(b: &mut Bencher) {
- let expected = Last::new(1);
- let v: Vec<Result<isize, String>> = vec![Ok(1); 3000];
- b.iter(|| {
- let result: Result<Last<isize>, String> = from_iter_with_scan_with_freevar(v.iter().cloned());
- assert_eq!(result.unwrap(), expected);
- });
- }
- #[bench]
- fn bench_last_from_iter_with_filter_map__(b: &mut Bencher) {
- let expected = Last::new(1);
- let v: Vec<Result<isize, String>> = vec![Ok(1); 3000];
- b.iter(|| {
- let result: Result<Last<isize>, String> = from_iter_with_filter_map(v.iter().cloned());
- assert_eq!(result.unwrap(), expected);
- });
- }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement