1 use {Async, Poll};
2 use stream::Stream;
3
4 /// A stream which is just a shim over an underlying instance of `Iterator`.
5 ///
6 /// This stream will never block and is always ready.
7 #[derive(Debug)]
8 #[must_use = "streams do nothing unless polled"]
9 pub struct IterResult<I> {
10 iter: I,
11 }
12
13 /// Converts an `Iterator` over `Result`s into a `Stream` which is always ready
14 /// to yield the next value.
15 ///
16 /// Iterators in Rust don't express the ability to block, so this adapter simply
17 /// always calls `iter.next()` and returns that.
18 ///
19 /// ```rust
20 /// use futures::*;
21 ///
22 /// let mut stream = stream::iter_result(vec![Ok(17), Err(false), Ok(19)]);
23 /// assert_eq!(Ok(Async::Ready(Some(17))), stream.poll());
24 /// assert_eq!(Err(false), stream.poll());
25 /// assert_eq!(Ok(Async::Ready(Some(19))), stream.poll());
26 /// assert_eq!(Ok(Async::Ready(None)), stream.poll());
27 /// ```
iter_result<J, T, E>(i: J) -> IterResult<J::IntoIter> where J: IntoIterator<Item = Result<T, E>>,28 pub fn iter_result<J, T, E>(i: J) -> IterResult<J::IntoIter>
29 where
30 J: IntoIterator<Item = Result<T, E>>,
31 {
32 IterResult {
33 iter: i.into_iter(),
34 }
35 }
36
37 impl<I, T, E> Stream for IterResult<I>
38 where
39 I: Iterator<Item = Result<T, E>>,
40 {
41 type Item = T;
42 type Error = E;
43
poll(&mut self) -> Poll<Option<T>, E>44 fn poll(&mut self) -> Poll<Option<T>, E> {
45 match self.iter.next() {
46 Some(Ok(e)) => Ok(Async::Ready(Some(e))),
47 Some(Err(e)) => Err(e),
48 None => Ok(Async::Ready(None)),
49 }
50 }
51 }
52