eater/async-std
1
0
Fork 0
forked from mirror/async-std
Code Issues Pull requests Releases Wiki Activity

Restructure package. No longer use a extension trait to match std.

Browse source 
Still outstanding: How do I hide the concrete structs from the trait?
This commit is contained in:
Felipe Sere 2019-11-28 12:33:37 +01:00
parent 41cf0f855b
commit 8e5dedec34
10 changed files with 246 additions and 295 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

267
src/stream/double_ended/mod.rs
View file

@ -1,267 +0,0 @@
mod next_back;
mod nth_back;
mod rfind;
mod rfold;
mod try_rfold;
mod from_iter;
use next_back::NextBackFuture;
use nth_back::NthBackFuture;
use rfind::RFindFuture;
use rfold::RFoldFuture;
use try_rfold::TryRFoldFuture;
pub use from_iter::{from_iter, FromIter};
extension_trait! {
use crate::stream::Stream;
use std::pin::Pin;
use std::task::{Context, Poll};
#[doc = r#"
A stream able to yield elements from both ends.
Something that implements `DoubleEndedStream` has one extra capability
over something that implements [`Stream`]: the ability to also take
`Item`s from the back, as well as the front.
It is important to note that both back and forth work on the same range,
and do not cross: iteration is over when they meet in the middle.
In a similar fashion to the [`Stream`] protocol, once a
`DoubleEndedStream` returns `None` from a `next_back()`, calling it again
may or may not ever return `Some` again. `next()` and `next_back()` are
interchangeable for this purpose.
```
"#]
pub trait DoubleEndedStream {
#[doc = r#"
The type of items yielded by this stream.
"#]
type Item;
#[doc = r#"
Attempts to receive the next item from the back of the stream.
There are several possible return values:
* `Poll::Pending` means this stream's next_back value is not ready yet.
* `Poll::Ready(None)` means this stream has been exhausted.
* `Poll::Ready(Some(item))` means `item` was received out of the stream.
# Examples
```
# fn main() { async_std::task::block_on(async {
#
use std::pin::Pin;
use async_std::prelude::*;
use async_std::stream;
use async_std::task::{Context, Poll};
fn increment(
s: impl DoubleEndedStream<Item = i32> + Unpin,
) -> impl DoubleEndedStream<Item = i32> + Unpin {
struct Increment<S>(S);
impl<S: DoubleEndedStream<Item = i32> + Unpin> Stream for Increment<S> {
type Item = S::Item;
fn poll_next_back(
mut self: Pin<&mut Self>,
cx: &mut Context<'_>,
) -> Poll<Option<Self::Item>> {
match Pin::new(&mut self.0).poll_next_back(cx) {
Poll::Pending => Poll::Pending,
Poll::Ready(None) => Poll::Ready(None),
Poll::Ready(Some(item)) => Poll::Ready(Some(item + 1)),
}
}
}
Increment(s)
}
let mut s = increment(stream::once(7)); // will need to implement DoubleEndedStream
assert_eq!(s.next_back().await, Some(8));
assert_eq!(s.next_back().await, None);
#
# }) }
```
"#]
fn poll_next_back(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>>;
}
#[doc = r#"
Extension methods for [`DoubleEndedStreamExt`].
[`Stream`]: ../stream/trait.Stream.html
"#]
pub trait DoubleEndedStreamExt: crate::stream::DoubleEndedStream {
#[doc = r#"
Advances the stream and returns the next value.
Returns [`None`] when iteration is finished. Individual stream implementations may
choose to resume iteration, and so calling `next()` again may or may not eventually
start returning more values.
[`None`]: https://doc.rust-lang.org/std/option/enum.Option.html#variant.None
# Examples
```
# fn main() { async_std::task::block_on(async {
#
use async_std::stream::double_ended::{self, DoubleEndedStreamExt};
let mut s = double_ended::from_iter(vec![7u8]);
assert_eq!(s.next_back().await, Some(7));
assert_eq!(s.next_back().await, None);
#
# }) }
```
"#]
fn next_back(&mut self) -> impl Future<Output = Option<Self::Item>> + '_ [NextBackFuture<'_, Self>]
where
Self: Unpin,
{
NextBackFuture { stream: self }
}
#[doc = r#"
Returns the nth element from the back of the stream.
# Examples
Basic usage:
```
# fn main() { async_std::task::block_on(async {
#
use async_std::stream::double_ended::{self, DoubleEndedStreamExt};
let mut s = double_ended::from_iter(vec![1u8, 2, 3, 4, 5]);
let second = s.nth_back(1).await;
assert_eq!(second, Some(4));
#
# }) }
```
"#]
fn nth_back(
&mut self,
n: usize,
) -> impl Future<Output = Option<Self::Item>> + '_ [NthBackFuture<'_, Self>]
where
Self: Unpin + Sized,
{
NthBackFuture::new(self, n)
}
#[doc = r#"
Returns the the frist element from the right that matches the predicate.
# Examples
Basic usage:
```
# fn main() { async_std::task::block_on(async {
#
use async_std::stream::double_ended::{self, DoubleEndedStreamExt};
let mut s = double_ended::from_iter(vec![1u8, 2, 3, 4, 5]);
let second = s.rfind(|v| v % 2 == 0).await;
assert_eq!(second, Some(4));
#
# }) }
```
"#]
fn rfind<P>(
&mut self,
p: P,
) -> impl Future<Output = Option<Self::Item>> + '_ [RFindFuture<'_, Self, P>]
where
Self: Unpin + Sized,
P: FnMut(&Self::Item) -> bool,
{
RFindFuture::new(self, p)
}
#[doc = r#"
# Examples
Basic usage:
```
# fn main() { async_std::task::block_on(async {
#
use async_std::stream::double_ended::{self, DoubleEndedStreamExt};
let s = double_ended::from_iter(vec![1u8, 2, 3, 4, 5]);
let second = s.rfold(0, |acc, v| v + acc).await;
assert_eq!(second, 15);
#
# }) }
```
"#]
fn rfold<B, F>(
self,
accum: B,
f: F,
) -> impl Future<Output = Option<B>> [RFoldFuture<Self, F, B>]
where
Self: Sized,
F: FnMut(B, Self::Item) -> B,
{
RFoldFuture::new(self, accum, f)
}
#[doc = r#"
A combinator that applies a function as long as it returns successfully, producing a single, final value.
Immediately returns the error when the function returns unsuccessfully.
# Examples
Basic usage:
```
# fn main() { async_std::task::block_on(async {
#
use async_std::stream::double_ended::{self, DoubleEndedStreamExt};
let s = double_ended::from_iter(vec![1u8, 2, 3, 4, 5]);
let sum = s.try_rfold(0, |acc, v| {
if (acc+v) % 2 == 1 {
Ok(v+3)
} else {
Err("fail")
}
}).await;
assert_eq!(sum, Err("fail"));
#
# }) }
```
"#]
fn try_rfold<B, F, E>(
self,
accum: B,
f: F,
) -> impl Future<Output = Option<B>> [TryRFoldFuture<Self, F, B>]
where
Self: Sized,
F: FnMut(B, Self::Item) -> Result<B, E>,
{
TryRFoldFuture::new(self, accum, f)
}
}
}

24
src/stream/double_ended_stream.rs
View file

@ -1,24 +0,0 @@
use crate::stream::Stream;
use std::pin::Pin;
use std::task::{Context, Poll};
/// A stream able to yield elements from both ends.
///
/// Something that implements `DoubleEndedStream` has one extra capability
/// over something that implements [`Stream`]: the ability to also take
/// `Item`s from the back, as well as the front.
///
/// [`Stream`]: trait.Stream.html
#[cfg(feature = "unstable")]
#[cfg_attr(feature = "docs", doc(cfg(unstable)))]
pub trait DoubleEndedStream: Stream {
/// Removes and returns an element from the end of the stream.
///
/// Returns `None` when there are no more elements.
///
/// The [trait-level] docs contain more details.
///
/// [trait-level]: trait.DoubleEndedStream.html
fn poll_next_back(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>>;
}

4
src/stream/double_ended/from_iter.rs → src/stream/double_ended_stream/from_iter.rs
View file

@ -22,9 +22,9 @@ pub struct FromIter<T> {
/// ``` /// ```
/// # async_std::task::block_on(async { /// # async_std::task::block_on(async {
/// # /// #
/// use async_std::stream::double_ended::{self, DoubleEndedStreamExt}; /// use async_std::stream::double_ended_stream::{self, DoubleEndedStream};
/// ///
/// let mut s = double_ended::from_iter(vec![0, 1, 2, 3]); /// let mut s = double_ended_stream::from_iter(vec![0, 1, 2, 3]);
/// ///
/// assert_eq!(s.next_back().await, Some(3)); /// assert_eq!(s.next_back().await, Some(3));
/// assert_eq!(s.next_back().await, Some(2)); /// assert_eq!(s.next_back().await, Some(2));

243
src/stream/double_ended_stream/mod.rs Normal file
View file

@ -0,0 +1,243 @@
use crate::stream::Stream;
use std::pin::Pin;
use std::task::{Context, Poll};
mod from_iter;
mod next_back;
mod nth_back;
mod rfind;
mod rfold;
mod try_rfold;
pub use from_iter::{from_iter, FromIter};
use next_back::NextBackFuture;
use nth_back::NthBackFuture;
use rfind::RFindFuture;
use rfold::RFoldFuture;
use try_rfold::TryRFoldFuture;
/// A stream able to yield elements from both ends.
///
/// Something that implements `DoubleEndedStream` has one extra capability
/// over something that implements [`Stream`]: the ability to also take
/// `Item`s from the back, as well as the front.
///
/// [`Stream`]: trait.Stream.html
#[cfg(feature = "unstable")]
#[cfg_attr(feature = "docs", doc(cfg(unstable)))]
pub trait DoubleEndedStream: Stream {
#[doc = r#"
Attempts to receive the next item from the back of the stream.
There are several possible return values:
* `Poll::Pending` means this stream's next_back value is not ready yet.
* `Poll::Ready(None)` means this stream has been exhausted.
* `Poll::Ready(Some(item))` means `item` was received out of the stream.
# Examples
```
# fn main() { async_std::task::block_on(async {
#
use std::pin::Pin;
use async_std::prelude::*;
use async_std::stream;
use async_std::task::{Context, Poll};
fn increment(
s: impl DoubleEndedStream<Item = i32> + Unpin,
) -> impl DoubleEndedStream<Item = i32> + Unpin {
struct Increment<S>(S);
impl<S: DoubleEndedStream<Item = i32> + Unpin> Stream for Increment<S> {
type Item = S::Item;
fn poll_next(
mut self: Pin<&mut Self>,
cx: &mut Context<'_>,
) -> Poll<Option<Self::Item>> {
match Pin::new(&mut self.0).poll_next(cx) {
Poll::Pending => Poll::Pending,
Poll::Ready(None) => Poll::Ready(None),
Poll::Ready(Some(item)) => Poll::Ready(Some(item + 1)),
}
}
}
impl<S: DoubleEndedStream<Item = i32> + Unpin> DoubleEndedStream for Increment<S> {
fn poll_next_back(
mut self: Pin<&mut Self>,
cx: &mut Context<'_>,
) -> Poll<Option<Self::Item>> {
match Pin::new(&mut self.0).poll_next_back(cx) {
Poll::Pending => Poll::Pending,
Poll::Ready(None) => Poll::Ready(None),
Poll::Ready(Some(item)) => Poll::Ready(Some(item + 1)),
}
}
}
Increment(s)
}
let mut s = increment(stream::once(7));
assert_eq!(s.next_back().await, Some(8));
assert_eq!(s.next_back().await, None);
#
# }) }
```
"#]
fn poll_next_back(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>>;
#[doc = r#"
Advances the stream and returns the next value.
Returns [`None`] when iteration is finished. Individual stream implementations may
choose to resume iteration, and so calling `next()` again may or may not eventually
start returning more values.
[`None`]: https://doc.rust-lang.org/std/option/enum.Option.html#variant.None
# Examples
```
# fn main() { async_std::task::block_on(async {
#
use async_std::stream::double_ended_stream::{self, DoubleEndedStream};
let mut s = double_ended_stream::from_iter(vec![7u8]);
assert_eq!(s.next_back().await, Some(7));
assert_eq!(s.next_back().await, None);
#
# }) }
```
"#]
fn next_back(&mut self) -> NextBackFuture<'_, Self>
where
Self: Unpin,
{
NextBackFuture { stream: self }
}
#[doc = r#"
Returns the nth element from the back of the stream.
# Examples
Basic usage:
```
# fn main() { async_std::task::block_on(async {
#
use async_std::stream::double_ended_stream::{self, DoubleEndedStream};
let mut s = double_ended_stream::from_iter(vec![1u8, 2, 3, 4, 5]);
let second = s.nth_back(1).await;
assert_eq!(second, Some(4));
#
# }) }
```
"#]
fn nth_back(&mut self, n: usize) -> NthBackFuture<'_, Self>
where
Self: Unpin + Sized,
{
NthBackFuture::new(self, n)
}
#[doc = r#"
Returns the the frist element from the right that matches the predicate.
# Examples
Basic usage:
```
# fn main() { async_std::task::block_on(async {
#
use async_std::stream::double_ended_stream::{self, DoubleEndedStream};
let mut s = double_ended_stream::from_iter(vec![1u8, 2, 3, 4, 5]);
let second = s.rfind(|v| v % 2 == 0).await;
assert_eq!(second, Some(4));
#
# }) }
```
"#]
fn rfind<P>(&mut self, p: P) -> RFindFuture<'_, Self, P>
where
Self: Unpin + Sized,
P: FnMut(&Self::Item) -> bool,
{
RFindFuture::new(self, p)
}
#[doc = r#"
# Examples
Basic usage:
```
# fn main() { async_std::task::block_on(async {
#
use async_std::stream::double_ended_stream::{self, DoubleEndedStream};
let s = double_ended_stream::from_iter(vec![1u8, 2, 3, 4, 5]);
let second = s.rfold(0, |acc, v| v + acc).await;
assert_eq!(second, 15);
#
# }) }
```
"#]
fn rfold<B, F>(self, accum: B, f: F) -> RFoldFuture<Self, F, B>
where
Self: Sized,
F: FnMut(B, Self::Item) -> B,
{
RFoldFuture::new(self, accum, f)
}
#[doc = r#"
A combinator that applies a function as long as it returns successfully, producing a single, final value.
Immediately returns the error when the function returns unsuccessfully.
# Examples
Basic usage:
```
# fn main() { async_std::task::block_on(async {
#
use async_std::stream::double_ended_stream::{self, DoubleEndedStream};
let s = double_ended_stream::from_iter(vec![1u8, 2, 3, 4, 5]);
let sum = s.try_rfold(0, |acc, v| {
if (acc+v) % 2 == 1 {
Ok(v+3)
} else {
Err("fail")
}
}).await;
assert_eq!(sum, Err("fail"));
#
# }) }
```
"#]
fn try_rfold<B, F, E>(self, accum: B, f: F) -> TryRFoldFuture<Self, F, B>
where
Self: Sized,
F: FnMut(B, Self::Item) -> Result<B, E>,
{
TryRFoldFuture::new(self, accum, f)
}
}

0
src/stream/double_ended/next_back.rs → src/stream/double_ended_stream/next_back.rs
View file

0
src/stream/double_ended/nth_back.rs → src/stream/double_ended_stream/nth_back.rs
View file

0
src/stream/double_ended/rfind.rs → src/stream/double_ended_stream/rfind.rs
View file

0
src/stream/double_ended/rfold.rs → src/stream/double_ended_stream/rfold.rs
View file

0
src/stream/double_ended/try_rfold.rs → src/stream/double_ended_stream/try_rfold.rs
View file

3
src/stream/mod.rs
View file

@ -319,8 +319,7 @@ mod repeat_with;
cfg_unstable! { cfg_unstable! {
#[doc(hidden)] #[doc(hidden)]
pub mod double_ended; pub mod double_ended_stream;
mod double_ended_stream;
mod exact_size_stream; mod exact_size_stream;
mod extend; mod extend;
mod from_stream; mod from_stream;