      1
      2
      3
      4
      5
      6
      7
      8
      9
     10
     11
     12
     13
     14
     15
     16
     17
     18
     19
     20
     21
     22
     23
     24
     25
     26
     27
     28
     29
     30
     31
     32
     33
     34
     35
     36
     37
     38
     39
     40
     41
     42
     43
     44
     45
     46
     47
     48
     49
     50
     51
     52
     53
     54
     55
     56
     57
     58
     59
     60
     61
     62
     63
     64
     65
     66
     67
     68
     69
     70
     71
     72
     73
     74
     75
     76
     77
     78
     79
     80
     81
     82
     83
     84
     85
     86
     87
     88
     89
     90
     91
     92
     93
     94
     95
     96
     97
     98
     99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119

    //! Asynchronous streams.
    //!
    //! This module contains:
    //!
    //! - The [`Stream`] trait, for objects that can asynchronously produce a
    //!   sequence of values.
    //! - The [`StreamExt`] and [`TryStreamExt`] trait, which provides adapters for
    //!   chaining and composing streams.
    //! - Top-level stream constructors like [`iter`](iter()) which creates a
    //!   stream from an iterator.

    #[cfg(feature = "alloc")]
    pub use futures_core::stream::{BoxStream, LocalBoxStream};
    pub use futures_core::stream::{FusedStream, Stream, TryStream};

    // Extension traits and combinators

    #[allow(clippy::module_inception)]
    mod stream;
    pub use self::stream::{
        Chain, Collect, Concat, Cycle, Enumerate, Filter, FilterMap, FlatMap, Flatten, Fold, ForEach,
        Fuse, Inspect, Map, Next, Peek, Peekable, Scan, SelectNextSome, Skip, SkipWhile, StreamExt,
        StreamFuture, Take, TakeUntil, TakeWhile, Then, Unzip, Zip,
    };

    #[cfg(feature = "std")]
    pub use self::stream::CatchUnwind;

    #[cfg(feature = "alloc")]
    pub use self::stream::Chunks;

    #[cfg(feature = "alloc")]
    pub use self::stream::ReadyChunks;

    #[cfg(feature = "sink")]
    #[cfg_attr(docsrs, doc(cfg(feature = "sink")))]
    pub use self::stream::Forward;

    #[cfg_attr(feature = "cfg-target-has-atomic", cfg(target_has_atomic = "ptr"))]
    #[cfg(feature = "alloc")]
    pub use self::stream::{BufferUnordered, Buffered, ForEachConcurrent};

    #[cfg_attr(feature = "cfg-target-has-atomic", cfg(target_has_atomic = "ptr"))]
    #[cfg(feature = "sink")]
    #[cfg_attr(docsrs, doc(cfg(feature = "sink")))]
    #[cfg(feature = "alloc")]
    pub use self::stream::{ReuniteError, SplitSink, SplitStream};

    mod try_stream;
    pub use self::try_stream::{
        try_unfold, AndThen, ErrInto, InspectErr, InspectOk, IntoStream, MapErr, MapOk, OrElse,
        TryCollect, TryConcat, TryFilter, TryFilterMap, TryFlatten, TryFold, TryForEach, TryNext,
        TrySkipWhile, TryStreamExt, TryTakeWhile, TryUnfold,
    };

    #[cfg(feature = "io")]
    #[cfg_attr(docsrs, doc(cfg(feature = "io")))]
    #[cfg(feature = "std")]
    pub use self::try_stream::IntoAsyncRead;

    #[cfg_attr(feature = "cfg-target-has-atomic", cfg(target_has_atomic = "ptr"))]
    #[cfg(feature = "alloc")]
    pub use self::try_stream::{TryBufferUnordered, TryBuffered, TryForEachConcurrent};

    // Primitive streams

    mod iter;
    pub use self::iter::{iter, Iter};

    mod repeat;
    pub use self::repeat::{repeat, Repeat};

    mod repeat_with;
    pub use self::repeat_with::{repeat_with, RepeatWith};

    mod empty;
    pub use self::empty::{empty, Empty};

    mod once;
    pub use self::once::{once, Once};

    mod pending;
    pub use self::pending::{pending, Pending};

    mod poll_fn;
    pub use self::poll_fn::{poll_fn, PollFn};

    mod select;
    pub use self::select::{select, Select};

    mod unfold;
    pub use self::unfold::{unfold, Unfold};

    cfg_target_has_atomic! {
        #[cfg(feature = "alloc")]
        mod futures_ordered;
        #[cfg(feature = "alloc")]
        pub use self::futures_ordered::FuturesOrdered;

        #[cfg(feature = "alloc")]
        pub mod futures_unordered;
        #[cfg(feature = "alloc")]
        #[doc(inline)]
        pub use self::futures_unordered::FuturesUnordered;

        #[cfg(feature = "alloc")]
        mod select_all;
        #[cfg(feature = "alloc")]
        pub use self::select_all::{select_all, SelectAll};
    }

    // Just a helper function to ensure the streams we're returning all have the
    // right implementations.
    pub(crate) fn assert_stream<T, S>(stream: S) -> S
    where
        S: Stream<Item = T>,
    {
        stream
    }