try_all 0.0.2

Extends iterators with `try_all` to convert iterator of results into result of iterator of okays
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122

type Recollector<T> = std::vec::IntoIter<T>;

/// Trait providing try map (result) extensions to Iterators.
///
/// See [`TryMapAll::try_map_all`].
///
/// Once `Try` (#42327) is stabilized, hopefully the `Result` and `Option` variants can be merged and generalized.
pub trait TryMapAll {
	type Item;
	/// Applies a closure on all items of the iterator until one fails (or all succeed).
	///
	/// # Arguments
	///
	/// - `f`: fallible mapping function
	///
	/// # Returns
	///
	/// The iterator of all successes, or the first failure.
	/// 
	/// # Examples
	///
	/// Useful for propagating failures from within closures with `?` operator:
	/// ```rust
	/// # use crate::try_all::*;
	/// fn all_numbers_x2(strs: &Vec<&str>) -> Result<Vec<u64>, std::num::ParseIntError> {
	/// 	Ok(strs.iter().try_map_all(|s| Ok(s.parse::<u64>()?*2))?.collect())
	/// }
	/// ```
	///
	/// # Equivalence
	///
	/// `iter.try_map_all(f)` is equivalent to `iter.map(f).try_all()`, except the latter works with `Option`s just as well (or check out [`TryMapAllOption::try_map_all_opt()`]).
	///
	/// Additionally, it is equivalent to
	/// ```rust
	/// # fn hehe<U, T, E>(iter: impl Iterator<Item=U>, f: impl Fn(U) -> Result<T, E>) -> Result<Vec<T>, E> {
	///	let mut acc = Vec::new();
	/// for item in iter {
	/// 	acc.push(f(item)?);
	/// }
	/// Ok(acc)
	/// # }
	/// ```
	///
	/// Due to the nature of operation, the function has to collect intermediate results.
	/// In other words, if `f` has side effects, expect them for all applications until \[including\] first failure.
	/// Additionally, this won't work on infinite sequences :o.
	fn try_map_all<T, E>(self, f: impl Fn(Self::Item) -> Result<T, E>) -> Result<Recollector<T>, E>;
}

impl<I: Iterator> TryMapAll for I {
	type Item = I::Item;
	fn try_map_all<T, E>(self, f: impl Fn(Self::Item) -> Result<T, E>) -> Result<Recollector<T>, E> {
		let mut ok = Vec::new();
		for t in self {
			ok.push(f(t)?);
		}
		Ok(ok.into_iter())
	}
}

/// Trait providing try map (option) extensions to Iterators.
///
/// See [`TryMapAllOption::try_map_all_opt`].
///
/// Once `Try` (#42327) is stabilized, hopefully the `Result` and `Option` variants can be merged and generalized.
pub trait TryMapAllOption {
	type Item;
	/// Applies a closure on all items of the iterator until one fails (or all succeed).
	///
	/// This is [`TryMapAll::try_map_all`] - `Option` edition.
	///
	/// # Arguments
	///
	/// - `f`: fallible mapping function
	///
	/// # Returns
	///
	/// The iterator of all successes, or the first failure.
	/// 
	/// # Examples
	///
	/// Useful for propagating failures from within closures with `?` operator:
	/// ```rust
	/// # use crate::try_all::*;
	/// fn not_zero(is: Vec<u64>) -> Option<Vec<u64>> {
	/// 	Some(is.into_iter().try_map_all_opt(|i| if i > 0 { Some(i) } else { None })?.collect())
	/// }
	/// ```
	///
	/// Due to the nature of operation, the function has to collect intermediate results.
	/// In other words, if `f` has side effects, expect them for all applications until \[including\] first failure.
	/// Additionally, this won't work on infinite sequences :o.
	fn try_map_all_opt<T>(self, f: impl Fn(Self::Item) -> Option<T>) -> Option<Recollector<T>>;
}

impl<I: Iterator> TryMapAllOption for I {
	type Item = I::Item;
	fn try_map_all_opt<T>(self, f: impl Fn(Self::Item) -> Option<T>) -> Option<Recollector<T>> {
		let mut ok = Vec::new();
		for t in self {
			ok.push(f(t)?);
		}
		Some(ok.into_iter())
	}
}

#[cfg(test)]
mod test {
	use super::*;
	#[test]
	fn test_try_map_all(){
		assert_eq!(vec![Ok(0), Ok(1), Ok(2), Err("no u!")].into_iter().take(3).try_map_all(|i| i).map(|v| v.collect()), Ok(vec![0, 1, 2]));
		assert_eq!(vec![Ok(0), Ok(1), Err("no u!")].into_iter().try_map_all(|i| i).map(|v| v.collect::<Vec<_>>()), Err("no u!"));
		assert_eq!(vec![Err("me is 1st"), Ok(1), Err("no u!")].into_iter().try_map_all(|i| i).map(|v| v.collect::<Vec<_>>()), Err("me is 1st"));
	}
	#[test]
	fn test_try_map_all_opt(){
		assert_eq!(vec![Some(0), Some(1), Some(2)].into_iter().try_map_all_opt(|i| i).map(|v| v.collect::<Vec<_>>()), Some(vec![0, 1, 2]));
		assert_eq!(vec![Some(0), None, Some(2)].into_iter().try_map_all_opt(|i| i).map(|v| v.collect::<Vec<_>>()), None);
	}
}