fn map<F, O>(self, func: F) -> Map<Self, F>
        where Self: Sized,
              F: FnMut(Self::Item) -> O
    {
        Map::new(self, func)
    }
/// Takes a closure and creates a stream which calls that closure on each
/// element. `map()` transforms one stream into another, by means of its
/// argument: something that implements FnMut. It produces a new stream
/// which calls this closure on each element of the original stream.
///
/// If you are good at thinking in types, you can think of map() like this:
/// If you have a stream that gives you elements of some type A, and you
/// want a stream of some other type B, you can use `map()`, passing a
/// closure that takes an A and returns a B. `map()` is conceptually similar
/// to a for loop. However, as `map()` is lazy, it is best used when you're
/// already working with other streams. If you're doing some sort of looping
/// for a side effect, it's considered more idiomatic to use for than
/// `map()`.`
///
/// # Examples
///
/// ```
/// use asyncplify::*;
///
/// let mut value = 0;
///
/// let vec = (0..4)
///     .into_stream()
///     .map(|v| v + 10)
///     .into_vec();
/// assert!(vec == [10, 11, 12, 13], "vec = {:?}", vec);
/// ```
Takes a closure and creates a stream which calls that closure on each
element. `map()` transforms one stream into another, by means of its
argument: something that implements FnMut. It produces a new stream
which calls this closure on each element of the original stream.

If you are good at thinking in types, you can think of map() like this:
If you have a stream that gives you elements of some type A, and you
want a stream of some other type B, you can use `map()`, passing a
closure that takes an A and returns a B. `map()` is conceptually similar
to a for loop. However, as `map()` is lazy, it is best used when you're
already working with other streams. If you're doing some sort of looping
for a side effect, it's considered more idiomatic to use for than
`map()`.`
Takes a closure and creates a stream which calls that closure on each element . ` map () ` transforms one stream into another by means of its argument : something that implements FnMut . It produces a new stream which calls this closure on each element of the original stream . If you are good at thinking in types you can think of map () like this : If you have a stream that gives you elements of some type A and you want a stream of some other type B you can use ` map () ` passing a closure that takes an A and returns a B . ` map () ` is conceptually similar to a for loop . However as ` map () ` is lazy it is best used when you ' re already working with other streams . If you ' re doing some sort of looping for a side effect it ' s considered more idiomatic to use for than ` map () ` . `
fn map<F, O>(self, func: F) -> Map<Self, F>
        where Self: Sized,
              F: FnMut(Self::Item) -> O
    {
        Map::new(self, func)
    }
fn map < F , O > ( self , func : F ) -> Map < Self , F > where Self : Sized , F : FnMut ( Self :: Item ) -> O { Map :: new ( self , func ) }
Takes a closure and creates a stream which calls that closure on each
element.
Takes a closure and creates a stream which calls that closure on each element .
self
func
F
self
func
F
examples
```
use asyncplify::*.

let mut value = 0.


` ` ` use asyncplify :: * . let mut value = 0 .