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

Replace VecDeque with stream::from_iter in examples (#447)

Browse source
This commit is contained in:
nasa 2019-11-03 21:40:51 +09:00 committed by Stjepan Glavina
parent fa91d7f856
commit ddbbbfc32a
5 changed files with 143 additions and 153 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
src/option/sum.rs
View file

@ -20,12 +20,10 @@ where
``` ```
# fn main() { async_std::task::block_on(async { # fn main() { async_std::task::block_on(async {
# #
use std::collections::VecDeque;
use async_std::prelude::*; use async_std::prelude::*;
use async_std::stream;
let words: VecDeque<_> = vec!["have", "a", "great", "day"] let words = stream::from_iter(vec!["have", "a", "great", "day"]);
.into_iter()
.collect();
let total: Option<usize> = words.map(|w| w.find('a')).sum().await; let total: Option<usize> = words.map(|w| w.find('a')).sum().await;
assert_eq!(total, Some(5)); assert_eq!(total, Some(5));
# #

4
src/result/product.rs
View file

@ -20,10 +20,10 @@ where
``` ```
# fn main() { async_std::task::block_on(async { # fn main() { async_std::task::block_on(async {
# #
use std::collections::VecDeque;
use async_std::prelude::*; use async_std::prelude::*;
use async_std::stream;
let v: VecDeque<_> = vec![1, 2, 4].into_iter().collect(); let v = stream::from_iter(vec![1, 2, 4]);
let res: Result<i32, &'static str> = v.map(|x| let res: Result<i32, &'static str> = v.map(|x|
if x < 0 { if x < 0 {
Err("Negative element found") Err("Negative element found")

4
src/result/sum.rs
View file

@ -20,10 +20,10 @@ where
``` ```
# fn main() { async_std::task::block_on(async { # fn main() { async_std::task::block_on(async {
# #
use std::collections::VecDeque;
use async_std::prelude::*; use async_std::prelude::*;
use async_std::stream;
let v: VecDeque<_> = vec![1, 2].into_iter().collect(); let v = stream::from_iter(vec![1, 2]);
let res: Result<i32, &'static str> = v.map(|x| let res: Result<i32, &'static str> = v.map(|x|
if x < 0 { if x < 0 {
Err("Negative element found") Err("Negative element found")

2
src/stream/from_iter.rs
View file

@ -12,7 +12,7 @@ pin_project! {
/// See it documentation for more. /// See it documentation for more.
/// ///
/// [`from_iter`]: fn.from_iter.html /// [`from_iter`]: fn.from_iter.html
#[derive(Debug)] #[derive(Clone, Debug)]
pub struct FromIter<I> { pub struct FromIter<I> {
iter: I, iter: I,
} }

280
src/stream/stream/mod.rs
View file

@ -280,11 +280,10 @@ extension_trait! {
``` ```
# fn main() { async_std::task::block_on(async { # fn main() { async_std::task::block_on(async {
# #
use std::collections::VecDeque;
use async_std::prelude::*; use async_std::prelude::*;
use async_std::stream;
let s: VecDeque<usize> = vec![1, 2, 3, 4].into_iter().collect(); let s = stream::from_iter(vec![1, 2, 3, 4]);
let mut s = s.take_while(|x| x < &3 ); let mut s = s.take_while(|x| x < &3 );
assert_eq!(s.next().await, Some(1)); assert_eq!(s.next().await, Some(1));
@ -317,9 +316,9 @@ extension_trait! {
# fn main() { async_std::task::block_on(async { # fn main() { async_std::task::block_on(async {
# #
use async_std::prelude::*; use async_std::prelude::*;
use std::collections::VecDeque; use async_std::stream;
let s: VecDeque<_> = vec![0u8, 1, 2, 3, 4].into_iter().collect(); let s = stream::from_iter(vec![0u8, 1, 2, 3, 4]);
let mut stepped = s.step_by(2); let mut stepped = s.step_by(2);
assert_eq!(stepped.next().await, Some(0)); assert_eq!(stepped.next().await, Some(0));
@ -349,10 +348,10 @@ extension_trait! {
# fn main() { async_std::task::block_on(async { # fn main() { async_std::task::block_on(async {
# #
use async_std::prelude::*; use async_std::prelude::*;
use std::collections::VecDeque; use async_std::stream;
let first: VecDeque<_> = vec![0u8, 1].into_iter().collect(); let first = stream::from_iter(vec![0u8, 1]);
let second: VecDeque<_> = vec![2, 3].into_iter().collect(); let second = stream::from_iter(vec![2, 3]);
let mut c = first.chain(second); let mut c = first.chain(second);
assert_eq!(c.next().await, Some(0)); assert_eq!(c.next().await, Some(0));
@ -385,18 +384,17 @@ extension_trait! {
# fn main() { async_std::task::block_on(async { # fn main() { async_std::task::block_on(async {
# #
use async_std::prelude::*; use async_std::prelude::*;
use std::collections::VecDeque; use async_std::stream;
let v: VecDeque<_> = vec![&1, &2, &3].into_iter().collect(); let s = stream::from_iter(vec![&1, &2, &3]);
let second = stream::from_iter(vec![2, 3]);
let mut v_copied = v.copied();
assert_eq!(v_copied.next().await, Some(1));
assert_eq!(v_copied.next().await, Some(2));
assert_eq!(v_copied.next().await, Some(3));
assert_eq!(v_copied.next().await, None);
let mut s_copied = s.copied();
assert_eq!(s_copied.next().await, Some(1));
assert_eq!(s_copied.next().await, Some(2));
assert_eq!(s_copied.next().await, Some(3));
assert_eq!(s_copied.next().await, None);
# #
# }) } # }) }
``` ```
@ -422,9 +420,9 @@ extension_trait! {
# fn main() { async_std::task::block_on(async { # fn main() { async_std::task::block_on(async {
# #
use async_std::prelude::*; use async_std::prelude::*;
use std::collections::VecDeque; use async_std::stream;
let s: VecDeque<_> = vec!['a', 'b', 'c'].into_iter().collect(); let s = stream::from_iter(vec!['a', 'b', 'c']);
let mut s = s.enumerate(); let mut s = s.enumerate();
assert_eq!(s.next().await, Some((0, 'a'))); assert_eq!(s.next().await, Some((0, 'a')));
@ -452,9 +450,9 @@ extension_trait! {
# fn main() { async_std::task::block_on(async { # fn main() { async_std::task::block_on(async {
# #
use async_std::prelude::*; use async_std::prelude::*;
use std::collections::VecDeque; use async_std::stream;
let s: VecDeque<_> = vec![1, 2, 3].into_iter().collect(); let s = stream::from_iter(vec![1, 2, 3]);
let mut s = s.map(|x| 2 * x); let mut s = s.map(|x| 2 * x);
assert_eq!(s.next().await, Some(2)); assert_eq!(s.next().await, Some(2));
@ -486,10 +484,11 @@ extension_trait! {
# fn main() { async_std::task::block_on(async { # fn main() { async_std::task::block_on(async {
# #
use async_std::prelude::*; use async_std::prelude::*;
use std::collections::VecDeque; use async_std::stream;
let a: VecDeque<_> = vec![1u8, 2, 3, 4, 5].into_iter().collect(); let s = stream::from_iter(vec![1, 2, 3, 4, 5]);
let sum = a
let sum = s
.inspect(|x| println!("about to filter {}", x)) .inspect(|x| println!("about to filter {}", x))
.filter(|x| x % 2 == 0) .filter(|x| x % 2 == 0)
.inspect(|x| println!("made it through filter: {}", x)) .inspect(|x| println!("made it through filter: {}", x))
@ -518,11 +517,10 @@ extension_trait! {
``` ```
# fn main() { async_std::task::block_on(async { # fn main() { async_std::task::block_on(async {
# #
use std::collections::VecDeque;
use async_std::prelude::*; use async_std::prelude::*;
use async_std::stream;
let s: VecDeque<usize> = vec![1, 2, 3].into_iter().collect(); let s = stream::from_iter(vec![1, 2, 3]);
let last = s.last().await; let last = s.last().await;
assert_eq!(last, Some(3)); assert_eq!(last, Some(3));
@ -534,11 +532,10 @@ extension_trait! {
``` ```
# fn main() { async_std::task::block_on(async { # fn main() { async_std::task::block_on(async {
# #
use std::collections::VecDeque; use async_std::stream;
use crate::async_std::prelude::*;
use async_std::prelude::*; let s = stream::empty::<()>();
let s: VecDeque<usize> = vec![].into_iter().collect();
let last = s.last().await; let last = s.last().await;
assert_eq!(last, None); assert_eq!(last, None);
@ -599,11 +596,10 @@ extension_trait! {
``` ```
# fn main() { async_std::task::block_on(async { # fn main() { async_std::task::block_on(async {
# #
use std::collections::VecDeque;
use async_std::prelude::*; use async_std::prelude::*;
use async_std::stream;
let s: VecDeque<usize> = vec![1, 2, 3, 4].into_iter().collect(); let s = stream::from_iter(vec![1, 2, 3, 4]);
let mut s = s.filter(|i| i % 2 == 0); let mut s = s.filter(|i| i % 2 == 0);
assert_eq!(s.next().await, Some(2)); assert_eq!(s.next().await, Some(2));
@ -631,14 +627,14 @@ extension_trait! {
``` ```
# async_std::task::block_on(async { # async_std::task::block_on(async {
use std::collections::VecDeque;
use async_std::prelude::*; use async_std::prelude::*;
use async_std::stream::IntoStream; use async_std::stream::IntoStream;
use async_std::stream;
let inner1: VecDeque<u8> = vec![1,2,3].into_iter().collect(); let inner1 = stream::from_iter(vec![1,2,3]);
let inner2: VecDeque<u8> = vec![4,5,6].into_iter().collect(); let inner2 = stream::from_iter(vec![4,5,6]);
let s: VecDeque<_> = vec![inner1, inner2].into_iter().collect(); let s = stream::from_iter(vec![inner1, inner2]);
let v :Vec<_> = s.flat_map(|s| s.into_stream()).collect().await; let v :Vec<_> = s.flat_map(|s| s.into_stream()).collect().await;
@ -668,12 +664,12 @@ extension_trait! {
``` ```
# async_std::task::block_on(async { # async_std::task::block_on(async {
use std::collections::VecDeque;
use async_std::prelude::*; use async_std::prelude::*;
use async_std::stream;
let inner1: VecDeque<u8> = vec![1,2,3].into_iter().collect(); let inner1 = stream::from_iter(vec![1u8,2,3]);
let inner2: VecDeque<u8> = vec![4,5,6].into_iter().collect(); let inner2 = stream::from_iter(vec![4u8,5,6]);
let s: VecDeque<_> = vec![inner1, inner2].into_iter().collect(); let s = stream::from_iter(vec![inner1, inner2]);
let v: Vec<_> = s.flatten().collect().await; let v: Vec<_> = s.flatten().collect().await;
@ -701,11 +697,11 @@ extension_trait! {
``` ```
# fn main() { async_std::task::block_on(async { # fn main() { async_std::task::block_on(async {
# #
use std::collections::VecDeque;
use async_std::prelude::*; use async_std::prelude::*;
use async_std::stream;
let s: VecDeque<&str> = vec!["1", "lol", "3", "NaN", "5"].into_iter().collect(); let s = stream::from_iter(vec!["1", "lol", "3", "NaN", "5"]);
let mut parsed = s.filter_map(|a| a.parse::<u32>().ok()); let mut parsed = s.filter_map(|a| a.parse::<u32>().ok());
@ -742,16 +738,15 @@ extension_trait! {
``` ```
# fn main() { async_std::task::block_on(async { # fn main() { async_std::task::block_on(async {
# #
use std::collections::VecDeque;
use async_std::prelude::*; use async_std::prelude::*;
use async_std::stream;
let s: VecDeque<i32> = vec![1, 2, -3].into_iter().collect(); let s = stream::from_iter(vec![1isize, 2, -3]);
let min = s.clone().min_by_key(|x| x.abs()).await; let min = s.clone().min_by_key(|x| x.abs()).await;
assert_eq!(min, Some(1)); assert_eq!(min, Some(1));
let min = VecDeque::<isize>::new().min_by_key(|x| x.abs()).await; let min = stream::empty::<isize>().min_by_key(|x| x.abs()).await;
assert_eq!(min, None); assert_eq!(min, None);
# #
# }) } # }) }
@ -779,16 +774,15 @@ extension_trait! {
``` ```
# fn main() { async_std::task::block_on(async { # fn main() { async_std::task::block_on(async {
# #
use std::collections::VecDeque;
use async_std::prelude::*; use async_std::prelude::*;
use async_std::stream;
let s: VecDeque<i32> = vec![-1, -2, -3].into_iter().collect(); let s = stream::from_iter(vec![-1isize, -2, -3]);
let max = s.clone().max_by_key(|x| x.abs()).await; let max = s.clone().max_by_key(|x| x.abs()).await;
assert_eq!(max, Some(3)); assert_eq!(max, Some(3));
let max = VecDeque::<isize>::new().max_by_key(|x| x.abs()).await; let max = stream::empty::<isize>().min_by_key(|x| x.abs()).await;
assert_eq!(max, None); assert_eq!(max, None);
# #
# }) } # }) }
@ -816,11 +810,10 @@ extension_trait! {
``` ```
# fn main() { async_std::task::block_on(async { # fn main() { async_std::task::block_on(async {
# #
use std::collections::VecDeque;
use async_std::prelude::*; use async_std::prelude::*;
use async_std::stream;
let s: VecDeque<usize> = vec![1, 2, 3].into_iter().collect(); let s = stream::from_iter(vec![1u8, 2, 3]);
let min = s.clone().min_by(|x, y| x.cmp(y)).await; let min = s.clone().min_by(|x, y| x.cmp(y)).await;
assert_eq!(min, Some(1)); assert_eq!(min, Some(1));
@ -828,7 +821,7 @@ extension_trait! {
let min = s.min_by(|x, y| y.cmp(x)).await; let min = s.min_by(|x, y| y.cmp(x)).await;
assert_eq!(min, Some(3)); assert_eq!(min, Some(3));
let min = VecDeque::<usize>::new().min_by(|x, y| x.cmp(y)).await; let min = stream::empty::<u8>().min_by(|x, y| x.cmp(y)).await;
assert_eq!(min, None); assert_eq!(min, None);
# #
# }) } # }) }
@ -854,15 +847,15 @@ extension_trait! {
```ignore ```ignore
# fn main() { async_std::task::block_on(async { # fn main() { async_std::task::block_on(async {
# #
use std::collections::VecDeque;
use async_std::prelude::*; use async_std::prelude::*;
use async_std::stream;
let s: VecDeque<usize> = vec![1, 2, 3].into_iter().collect(); let s = stream::from_iter(vec![1usize, 2, 3]);
let min = s.clone().min().await; let min = s.clone().min().await;
assert_eq!(min, Some(1)); assert_eq!(min, Some(1));
let min = VecDeque::<usize>::new().min().await; let min = stream::empty::<usize>().min().await;
assert_eq!(min, None); assert_eq!(min, None);
# #
# }) } # }) }
@ -888,11 +881,10 @@ extension_trait! {
``` ```
# fn main() { async_std::task::block_on(async { # fn main() { async_std::task::block_on(async {
# #
use std::collections::VecDeque;
use async_std::prelude::*; use async_std::prelude::*;
use async_std::stream;
let s: VecDeque<usize> = vec![1, 2, 3].into_iter().collect(); let s = stream::from_iter(vec![1u8, 2, 3]);
let max = s.clone().max_by(|x, y| x.cmp(y)).await; let max = s.clone().max_by(|x, y| x.cmp(y)).await;
assert_eq!(max, Some(3)); assert_eq!(max, Some(3));
@ -900,7 +892,7 @@ extension_trait! {
let max = s.max_by(|x, y| y.cmp(x)).await; let max = s.max_by(|x, y| y.cmp(x)).await;
assert_eq!(max, Some(1)); assert_eq!(max, Some(1));
let max = VecDeque::<usize>::new().max_by(|x, y| x.cmp(y)).await; let max = stream::empty::<usize>().max_by(|x, y| x.cmp(y)).await;
assert_eq!(max, None); assert_eq!(max, None);
# #
# }) } # }) }
@ -927,11 +919,10 @@ extension_trait! {
``` ```
# fn main() { async_std::task::block_on(async { # fn main() { async_std::task::block_on(async {
# #
use std::collections::VecDeque;
use async_std::prelude::*; use async_std::prelude::*;
use async_std::stream;
let mut s: VecDeque<usize> = vec![1, 2, 3].into_iter().collect(); let mut s = stream::from_iter(vec![1u8, 2, 3]);
let second = s.nth(1).await; let second = s.nth(1).await;
assert_eq!(second, Some(2)); assert_eq!(second, Some(2));
@ -943,11 +934,10 @@ extension_trait! {
``` ```
# fn main() { async_std::task::block_on(async { # fn main() { async_std::task::block_on(async {
# #
use std::collections::VecDeque; use async_std::stream;
use async_std::prelude::*; use async_std::prelude::*;
let mut s: VecDeque<usize> = vec![1, 2, 3].into_iter().collect(); let mut s = stream::from_iter(vec![1u8, 2, 3]);
let second = s.nth(0).await; let second = s.nth(0).await;
assert_eq!(second, Some(1)); assert_eq!(second, Some(1));
@ -961,11 +951,10 @@ extension_trait! {
``` ```
# fn main() { async_std::task::block_on(async { # fn main() { async_std::task::block_on(async {
# #
use std::collections::VecDeque;
use async_std::prelude::*; use async_std::prelude::*;
use async_std::stream;
let mut s: VecDeque<usize> = vec![1, 2, 3].into_iter().collect(); let mut s = stream::from_iter(vec![1u8, 2, 3]);
let fourth = s.nth(4).await; let fourth = s.nth(4).await;
assert_eq!(fourth, None); assert_eq!(fourth, None);
@ -1056,9 +1045,9 @@ extension_trait! {
# fn main() { async_std::task::block_on(async { # fn main() { async_std::task::block_on(async {
# #
use async_std::prelude::*; use async_std::prelude::*;
use std::collections::VecDeque; use async_std::stream;
let mut s: VecDeque<usize> = vec![1, 2, 3].into_iter().collect(); let mut s = stream::from_iter(vec![1u8, 2, 3]);
let res = s.find(|x| *x == 2).await; let res = s.find(|x| *x == 2).await;
assert_eq!(res, Some(2)); assert_eq!(res, Some(2));
# #
@ -1071,9 +1060,9 @@ extension_trait! {
# fn main() { async_std::task::block_on(async { # fn main() { async_std::task::block_on(async {
# #
use async_std::prelude::*; use async_std::prelude::*;
use std::collections::VecDeque; use async_std::stream;
let mut s: VecDeque<usize> = vec![1, 2, 3].into_iter().collect(); let mut s= stream::from_iter(vec![1, 2, 3]);
let res = s.find(|x| *x == 2).await; let res = s.find(|x| *x == 2).await;
assert_eq!(res, Some(2)); assert_eq!(res, Some(2));
@ -1101,9 +1090,9 @@ extension_trait! {
# fn main() { async_std::task::block_on(async { # fn main() { async_std::task::block_on(async {
# #
use async_std::prelude::*; use async_std::prelude::*;
use std::collections::VecDeque; use async_std::stream;
let mut s: VecDeque<&str> = vec!["lol", "NaN", "2", "5"].into_iter().collect(); let mut s = stream::from_iter(vec!["lol", "NaN", "2", "5"]);
let first_number = s.find_map(|s| s.parse().ok()).await; let first_number = s.find_map(|s| s.parse().ok()).await;
assert_eq!(first_number, Some(2)); assert_eq!(first_number, Some(2));
@ -1134,9 +1123,9 @@ extension_trait! {
# fn main() { async_std::task::block_on(async { # fn main() { async_std::task::block_on(async {
# #
use async_std::prelude::*; use async_std::prelude::*;
use std::collections::VecDeque; use async_std::stream;
let s: VecDeque<usize> = vec![1, 2, 3].into_iter().collect(); let s = stream::from_iter(vec![1u8, 2, 3]);
let sum = s.fold(0, |acc, x| acc + x).await; let sum = s.fold(0, |acc, x| acc + x).await;
assert_eq!(sum, 6); assert_eq!(sum, 6);
@ -1165,12 +1154,12 @@ extension_trait! {
# fn main() { async_std::task::block_on(async { # fn main() { async_std::task::block_on(async {
# #
use async_std::prelude::*; use async_std::prelude::*;
use std::collections::VecDeque; use async_std::stream;
use std::sync::mpsc::channel; use std::sync::mpsc::channel;
let (tx, rx) = channel(); let (tx, rx) = channel();
let s: VecDeque<usize> = vec![1, 2, 3].into_iter().collect(); let s = stream::from_iter(vec![1usize, 2, 3]);
let sum = s.for_each(move |x| tx.clone().send(x).unwrap()).await; let sum = s.for_each(move |x| tx.clone().send(x).unwrap()).await;
let v: Vec<_> = rx.iter().collect(); let v: Vec<_> = rx.iter().collect();
@ -1271,11 +1260,10 @@ extension_trait! {
``` ```
# fn main() { async_std::task::block_on(async { # fn main() { async_std::task::block_on(async {
# #
use std::collections::VecDeque;
use async_std::prelude::*; use async_std::prelude::*;
use async_std::stream;
let s: VecDeque<isize> = vec![1, 2, 3].into_iter().collect(); let s = stream::from_iter(vec![1isize, 2, 3]);
let mut s = s.scan(1, |state, x| { let mut s = s.scan(1, |state, x| {
*state = *state * x; *state = *state * x;
Some(-*state) Some(-*state)
@ -1312,11 +1300,10 @@ extension_trait! {
``` ```
# fn main() { async_std::task::block_on(async { # fn main() { async_std::task::block_on(async {
# #
use std::collections::VecDeque;
use async_std::prelude::*; use async_std::prelude::*;
use async_std::stream;
let a: VecDeque<_> = vec![-1i32, 0, 1].into_iter().collect(); let a = stream::from_iter(vec![-1i32, 0, 1]);
let mut s = a.skip_while(|x| x.is_negative()); let mut s = a.skip_while(|x| x.is_negative());
assert_eq!(s.next().await, Some(0)); assert_eq!(s.next().await, Some(0));
@ -1342,11 +1329,10 @@ extension_trait! {
``` ```
# fn main() { async_std::task::block_on(async { # fn main() { async_std::task::block_on(async {
# #
use std::collections::VecDeque;
use async_std::prelude::*; use async_std::prelude::*;
use async_std::stream;
let s: VecDeque<usize> = vec![1, 2, 3].into_iter().collect(); let s = stream::from_iter(vec![1u8, 2, 3]);
let mut skipped = s.skip(2); let mut skipped = s.skip(2);
assert_eq!(skipped.next().await, Some(3)); assert_eq!(skipped.next().await, Some(3));
@ -1408,9 +1394,9 @@ extension_trait! {
# fn main() { async_std::task::block_on(async { # fn main() { async_std::task::block_on(async {
# #
use async_std::prelude::*; use async_std::prelude::*;
use std::collections::VecDeque; use async_std::stream;
let s: VecDeque<usize> = vec![1, 2, 3].into_iter().collect(); let s = stream::from_iter(vec![1usize, 2, 3]);
let sum = s.try_fold(0, |acc, v| { let sum = s.try_fold(0, |acc, v| {
if (acc+v) % 2 == 1 { if (acc+v) % 2 == 1 {
Ok(v+3) Ok(v+3)
@ -1444,13 +1430,13 @@ extension_trait! {
``` ```
# fn main() { async_std::task::block_on(async { # fn main() { async_std::task::block_on(async {
# #
use std::collections::VecDeque;
use std::sync::mpsc::channel; use std::sync::mpsc::channel;
use async_std::prelude::*; use async_std::prelude::*;
use async_std::stream;
let (tx, rx) = channel(); let (tx, rx) = channel();
let s: VecDeque<usize> = vec![1, 2, 3].into_iter().collect(); let s = stream::from_iter(vec![1u8, 2, 3]);
let s = s.try_for_each(|v| { let s = s.try_for_each(|v| {
if v % 2 == 1 { if v % 2 == 1 {
tx.clone().send(v).unwrap(); tx.clone().send(v).unwrap();
@ -1502,12 +1488,11 @@ extension_trait! {
``` ```
# fn main() { async_std::task::block_on(async { # fn main() { async_std::task::block_on(async {
# #
use std::collections::VecDeque;
use async_std::prelude::*; use async_std::prelude::*;
use async_std::stream;
let l: VecDeque<isize> = vec![1, 2, 3].into_iter().collect(); let l = stream::from_iter(vec![1u8, 2, 3]);
let r: VecDeque<isize> = vec![4, 5, 6, 7].into_iter().collect(); let r = stream::from_iter(vec![4u8, 5, 6, 7]);
let mut s = l.zip(r); let mut s = l.zip(r);
assert_eq!(s.next().await, Some((1, 4))); assert_eq!(s.next().await, Some((1, 4)));
@ -1637,14 +1622,14 @@ extension_trait! {
# fn main() { async_std::task::block_on(async { # fn main() { async_std::task::block_on(async {
# #
use async_std::prelude::*; use async_std::prelude::*;
use std::collections::VecDeque; use async_std::stream;
use std::cmp::Ordering; use std::cmp::Ordering;
let s1 = VecDeque::from(vec![1]); let s1 = stream::from_iter(vec![1]);
let s2 = VecDeque::from(vec![1, 2]); let s2 = stream::from_iter(vec![1, 2]);
let s3 = VecDeque::from(vec![1, 2, 3]); let s3 = stream::from_iter(vec![1, 2, 3]);
let s4 = VecDeque::from(vec![1, 2, 4]); let s4 = stream::from_iter(vec![1, 2, 4]);
assert_eq!(s1.clone().partial_cmp(s1.clone()).await, Some(Ordering::Equal)); assert_eq!(s1.clone().partial_cmp(s1.clone()).await, Some(Ordering::Equal));
assert_eq!(s1.clone().partial_cmp(s2.clone()).await, Some(Ordering::Less)); assert_eq!(s1.clone().partial_cmp(s2.clone()).await, Some(Ordering::Less));
assert_eq!(s2.clone().partial_cmp(s1.clone()).await, Some(Ordering::Greater)); assert_eq!(s2.clone().partial_cmp(s1.clone()).await, Some(Ordering::Greater));
@ -1676,9 +1661,9 @@ extension_trait! {
# fn main() { async_std::task::block_on(async { # fn main() { async_std::task::block_on(async {
# #
use async_std::prelude::*; use async_std::prelude::*;
use std::collections::VecDeque; use async_std::stream;
let s: VecDeque<usize> = vec![1, 2, 3].into_iter().collect(); let s = stream::from_iter(vec![1usize, 2, 3]);
let res = s.clone().position(|x| *x == 1).await; let res = s.clone().position(|x| *x == 1).await;
assert_eq!(res, Some(0)); assert_eq!(res, Some(0));
@ -1715,13 +1700,14 @@ extension_trait! {
# fn main() { async_std::task::block_on(async { # fn main() { async_std::task::block_on(async {
# #
use async_std::prelude::*; use async_std::prelude::*;
use std::collections::VecDeque; use async_std::stream;
use std::cmp::Ordering; use std::cmp::Ordering;
let s1 = VecDeque::from(vec![1]);
let s2 = VecDeque::from(vec![1, 2]); let s1 = stream::from_iter(vec![1]);
let s3 = VecDeque::from(vec![1, 2, 3]); let s2 = stream::from_iter(vec![1, 2]);
let s4 = VecDeque::from(vec![1, 2, 4]); let s3 = stream::from_iter(vec![1, 2, 3]);
let s4 = stream::from_iter(vec![1, 2, 4]);
assert_eq!(s1.clone().cmp(s1.clone()).await, Ordering::Equal); assert_eq!(s1.clone().cmp(s1.clone()).await, Ordering::Equal);
assert_eq!(s1.clone().cmp(s2.clone()).await, Ordering::Less); assert_eq!(s1.clone().cmp(s2.clone()).await, Ordering::Less);
assert_eq!(s2.clone().cmp(s1.clone()).await, Ordering::Greater); assert_eq!(s2.clone().cmp(s1.clone()).await, Ordering::Greater);
@ -1751,11 +1737,13 @@ extension_trait! {
# fn main() { async_std::task::block_on(async { # fn main() { async_std::task::block_on(async {
# #
use async_std::prelude::*; use async_std::prelude::*;
use std::collections::VecDeque; use async_std::stream;
let single: VecDeque<isize> = vec![1].into_iter().collect();
let single_ne: VecDeque<isize> = vec![10].into_iter().collect(); let single = stream::from_iter(vec![1usize]);
let multi: VecDeque<isize> = vec![1,2].into_iter().collect(); let single_ne = stream::from_iter(vec![10usize]);
let multi_ne: VecDeque<isize> = vec![1,5].into_iter().collect(); let multi = stream::from_iter(vec![1usize,2]);
let multi_ne = stream::from_iter(vec![1usize,5]);
assert_eq!(single.clone().ne(single.clone()).await, false); assert_eq!(single.clone().ne(single.clone()).await, false);
assert_eq!(single_ne.clone().ne(single.clone()).await, true); assert_eq!(single_ne.clone().ne(single.clone()).await, true);
assert_eq!(multi.clone().ne(single_ne.clone()).await, true); assert_eq!(multi.clone().ne(single_ne.clone()).await, true);
@ -1786,12 +1774,13 @@ extension_trait! {
# fn main() { async_std::task::block_on(async { # fn main() { async_std::task::block_on(async {
# #
use async_std::prelude::*; use async_std::prelude::*;
use std::collections::VecDeque; use async_std::stream;
let single = stream::from_iter(vec![1]);
let single_gt = stream::from_iter(vec![10]);
let multi = stream::from_iter(vec![1,2]);
let multi_gt = stream::from_iter(vec![1,5]);
let single: VecDeque<isize> = vec![1].into_iter().collect();
let single_gt: VecDeque<isize> = vec![10].into_iter().collect();
let multi: VecDeque<isize> = vec![1,2].into_iter().collect();
let multi_gt: VecDeque<isize> = vec![1,5].into_iter().collect();
assert_eq!(single.clone().ge(single.clone()).await, true); assert_eq!(single.clone().ge(single.clone()).await, true);
assert_eq!(single_gt.clone().ge(single.clone()).await, true); assert_eq!(single_gt.clone().ge(single.clone()).await, true);
assert_eq!(multi.clone().ge(single_gt.clone()).await, false); assert_eq!(multi.clone().ge(single_gt.clone()).await, false);
@ -1822,12 +1811,13 @@ extension_trait! {
# fn main() { async_std::task::block_on(async { # fn main() { async_std::task::block_on(async {
# #
use async_std::prelude::*; use async_std::prelude::*;
use std::collections::VecDeque; use async_std::stream;
let single = stream::from_iter(vec![1]);
let single_eq = stream::from_iter(vec![10]);
let multi = stream::from_iter(vec![1,2]);
let multi_eq = stream::from_iter(vec![1,5]);
let single: VecDeque<isize> = vec![1].into_iter().collect();
let single_eq: VecDeque<isize> = vec![10].into_iter().collect();
let multi: VecDeque<isize> = vec![1,2].into_iter().collect();
let multi_eq: VecDeque<isize> = vec![1,5].into_iter().collect();
assert_eq!(single.clone().eq(single.clone()).await, true); assert_eq!(single.clone().eq(single.clone()).await, true);
assert_eq!(single_eq.clone().eq(single.clone()).await, false); assert_eq!(single_eq.clone().eq(single.clone()).await, false);
assert_eq!(multi.clone().eq(single_eq.clone()).await, false); assert_eq!(multi.clone().eq(single_eq.clone()).await, false);
@ -1858,12 +1848,13 @@ extension_trait! {
# fn main() { async_std::task::block_on(async { # fn main() { async_std::task::block_on(async {
# #
use async_std::prelude::*; use async_std::prelude::*;
use std::collections::VecDeque; use async_std::stream;
let single = stream::from_iter(vec![1]);
let single_gt = stream::from_iter(vec![10]);
let multi = stream::from_iter(vec![1,2]);
let multi_gt = stream::from_iter(vec![1,5]);
let single = VecDeque::from(vec![1]);
let single_gt = VecDeque::from(vec![10]);
let multi = VecDeque::from(vec![1,2]);
let multi_gt = VecDeque::from(vec![1,5]);
assert_eq!(single.clone().gt(single.clone()).await, false); assert_eq!(single.clone().gt(single.clone()).await, false);
assert_eq!(single_gt.clone().gt(single.clone()).await, true); assert_eq!(single_gt.clone().gt(single.clone()).await, true);
assert_eq!(multi.clone().gt(single_gt.clone()).await, false); assert_eq!(multi.clone().gt(single_gt.clone()).await, false);
@ -1894,12 +1885,13 @@ extension_trait! {
# fn main() { async_std::task::block_on(async { # fn main() { async_std::task::block_on(async {
# #
use async_std::prelude::*; use async_std::prelude::*;
use std::collections::VecDeque; use async_std::stream;
let single = stream::from_iter(vec![1]);
let single_gt = stream::from_iter(vec![10]);
let multi = stream::from_iter(vec![1,2]);
let multi_gt = stream::from_iter(vec![1,5]);
let single = VecDeque::from(vec![1]);
let single_gt = VecDeque::from(vec![10]);
let multi = VecDeque::from(vec![1,2]);
let multi_gt = VecDeque::from(vec![1,5]);
assert_eq!(single.clone().le(single.clone()).await, true); assert_eq!(single.clone().le(single.clone()).await, true);
assert_eq!(single.clone().le(single_gt.clone()).await, true); assert_eq!(single.clone().le(single_gt.clone()).await, true);
assert_eq!(multi.clone().le(single_gt.clone()).await, true); assert_eq!(multi.clone().le(single_gt.clone()).await, true);
@ -1930,12 +1922,12 @@ extension_trait! {
# fn main() { async_std::task::block_on(async { # fn main() { async_std::task::block_on(async {
# #
use async_std::prelude::*; use async_std::prelude::*;
use std::collections::VecDeque; use async_std::stream;
let single = VecDeque::from(vec![1]); let single = stream::from_iter(vec![1]);
let single_gt = VecDeque::from(vec![10]); let single_gt = stream::from_iter(vec![10]);
let multi = VecDeque::from(vec![1,2]); let multi = stream::from_iter(vec![1,2]);
let multi_gt = VecDeque::from(vec![1,5]); let multi_gt = stream::from_iter(vec![1,5]);
assert_eq!(single.clone().lt(single.clone()).await, false); assert_eq!(single.clone().lt(single.clone()).await, false);
assert_eq!(single.clone().lt(single_gt.clone()).await, true); assert_eq!(single.clone().lt(single_gt.clone()).await, true);
@ -1977,10 +1969,10 @@ extension_trait! {
``` ```
# fn main() { async_std::task::block_on(async { # fn main() { async_std::task::block_on(async {
# #
use std::collections::VecDeque;
use async_std::prelude::*; use async_std::prelude::*;
use async_std::stream;
let s: VecDeque<_> = vec![0u8, 1, 2, 3, 4].into_iter().collect(); let s = stream::from_iter(vec![0u8, 1, 2, 3, 4]);
let sum: u8 = s.sum().await; let sum: u8 = s.sum().await;
assert_eq!(sum, 10); assert_eq!(sum, 10);