Using a stream after the `for` loop

[alexcrichton]

Right now #[async] for will consume its stream argument (like for loops and iterators). Unlike iterators, however, there's not a great way to consume only half the stream and then continue using it afterwards (for example to break out early or reclaim resources).

With for loops you've got:

while let Some(x) = iter.next() {
    // ...
}

but there's not quite the same for streams!

[Arnavion]

The user can just give a &mut reference to their stream to the for-loop, no? &mut Stream also impls Stream

[alexcrichton]

Unfortunately right now due to borrowing restrictions in generators that won't work :(

[Arnavion]

Ah, you're right.

I guess then the current workaround is to manually loop over Stream::into_future() and bring the stream out of the loop.

fn foo<'a, S: Stream<Item = i32, Error = &'static str> + 'a>(mut s: S) -> impl Future<Item = (), Error = &'static str> + 'a {
	::async_block! {
		loop {
			match ::await!(s.into_future()) {
				Ok((Some(i), rest)) => {
					assert_eq!(i, 5);
					s = rest;

					// Only consume the first element.
					break;
				},

				Ok((None, rest)) | Err((_, rest)) => {
					s = rest;
					break;
				},
			}
		}

		assert_eq!(s.poll(), Ok(Async::Ready(Some(6))));

		Ok(())
	}
}

[alexcrichton]

Yeah I'd just hope we could get it a little more ergonomic than that :(

[withoutboats]

I believe this is solved by await_item!?