Struct FutureGroup 

pub struct FutureGroup<F> { /* private fields */ }

Available on crate feature nano-alloc only.

A growable group of futures which act as a single unit.

Example

Basic example

use futures_concurrency::future::FutureGroup;
use futures_lite::StreamExt;
use std::future;

let mut group = FutureGroup::new();
group.insert(future::ready(2));
group.insert(future::ready(4));

let mut out = 0;
while let Some(num) = group.next().await {
    out += num;
}
assert_eq!(out, 6);

Update the group on every iteration

use futures_concurrency::future::FutureGroup;
use lending_stream::prelude::*;
use std::future;

let mut group = FutureGroup::new();
group.insert(future::ready(4));

let mut index = 3;
let mut out = 0;
let mut group = group.lend_mut();
while let Some((group, num)) = group.next().await {
    if index != 0 {
        group.insert(future::ready(index));
        index -= 1;
    }
    out += num;
}
assert_eq!(out, 10);

Implementations

impl<F> FutureGroup<F>

pub fn new() -> FutureGroup<F>

Available on crate feature alloc only.

Create a new instance of FutureGroup.

Example

use futures_concurrency::future::FutureGroup;

let group = FutureGroup::new();

pub fn with_capacity(capacity: usize) -> FutureGroup<F>

Available on crate feature alloc only.

Create a new instance of FutureGroup with a given capacity.

Example

use futures_concurrency::future::FutureGroup;

let group = FutureGroup::with_capacity(2);

pub fn len(&self) -> usize

Available on crate feature alloc only.

Return the number of futures currently active in the group.

Example

use futures_concurrency::future::FutureGroup;
use futures_lite::StreamExt;
use std::future;

let mut group = FutureGroup::with_capacity(2);
assert_eq!(group.len(), 0);
group.insert(future::ready(12));
assert_eq!(group.len(), 1);

pub fn capacity(&self) -> usize

Available on crate feature alloc only.

Return the capacity of the FutureGroup.

Example

use futures_concurrency::future::FutureGroup;
use futures_lite::stream;

let group = FutureGroup::with_capacity(2);
assert!(group.capacity() >= 2);

pub fn is_empty(&self) -> bool

Available on crate feature alloc only.

Returns true if there are no futures currently active in the group.

Example

use futures_concurrency::future::FutureGroup;
use std::future;

let mut group = FutureGroup::with_capacity(2);
assert!(group.is_empty());
group.insert(future::ready(12));
assert!(!group.is_empty());

pub fn remove(&mut self, key: Key) -> bool

Available on crate feature alloc only.

Removes a stream from the group. Returns whether the value was present in the group.

Example

use futures_concurrency::future::FutureGroup;
use std::future;

let mut group = FutureGroup::new();
let key = group.insert(future::ready(4));
assert_eq!(group.len(), 1);
group.remove(key);
assert_eq!(group.len(), 0);

pub fn contains_key(&mut self, key: Key) -> bool

Available on crate feature alloc only.

Returns true if the FutureGroup contains a value for the specified key.

Example

use futures_concurrency::future::FutureGroup;
use std::future;

let mut group = FutureGroup::new();
let key = group.insert(future::ready(4));
assert!(group.contains_key(key));
group.remove(key);
assert!(!group.contains_key(key));

pub fn reserve(&mut self, additional: usize)

Available on crate feature alloc only.

Reserves capacity for additional more futures to be inserted. Does nothing if the capacity is already sufficient.

Example

use futures_concurrency::future::FutureGroup;
use std::future::Ready;
let mut group: FutureGroup<Ready<usize>> = FutureGroup::with_capacity(0);
assert_eq!(group.capacity(), 0);
group.reserve(10);
assert!(group.capacity() >= 10);

// does nothing if capacity is sufficient
group.reserve(5);
assert!(group.capacity() >= 10);

impl<F> FutureGroup<F>

where F: Future,

pub fn insert(&mut self, future: F) -> Key

where F: Future,

Available on crate feature alloc only.

Insert a new future into the group.

Example

use futures_concurrency::future::FutureGroup;
use std::future;

let mut group = FutureGroup::with_capacity(2);
group.insert(future::ready(12));

pub fn keyed(self) -> Keyed<F>

Available on crate feature alloc only.

Create a stream which also yields the key of each item.

Example

use futures_concurrency::future::FutureGroup;
use futures_lite::StreamExt;
use std::future;

let mut group = FutureGroup::new();
group.insert(future::ready(2));
group.insert(future::ready(4));

let mut out = 0;
let mut group = group.keyed();
while let Some((_key, num)) = group.next().await {
    out += num;
}
assert_eq!(out, 6);

Trait Implementations

impl<T> Debug for FutureGroup<T>

where T: Debug,

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<T> Default for FutureGroup<T>

fn default() -> FutureGroup<T>

Returns the “default value” for a type.

impl<F> Extend<F> for FutureGroup<F>

where F: Future,

fn extend<T>(&mut self, iter: T)

where T: IntoIterator<Item = F>,

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<F> FromIterator<F> for FutureGroup<F>

where F: Future,

fn from_iter<T>(iter: T) -> FutureGroup<F>

where T: IntoIterator<Item = F>,

Creates a value from an iterator.

impl<F> Stream for FutureGroup<F>

where F: Future,

type Item = <F as Future>::Output

Values yielded by the stream.

fn poll_next( self: Pin<&mut FutureGroup<F>>, cx: &mut Context<'_>, ) -> Poll<Option<<FutureGroup<F> as Stream>::Item>>

Attempt to pull out the next value of this stream, registering the current task for wakeup if the value is not yet available, and returning None if the stream is exhausted.

fn size_hint(&self) -> (usize, Option<usize>)

Returns the bounds on the remaining length of the stream.

impl<'pin, F> Unpin for FutureGroup<F>

where <PinnedFieldsOfHelperStruct<__FutureGroup<'pin, F>> as PinnedFieldsOfHelperTrait>::Actual: Unpin,