# Trait actix_web::actix::actix::ActorStream[−]

    pub trait ActorStream {
        type Item;
        type Error;
        type Actor: Actor;
        fn poll(
            &mut self,
            srv: &mut Self::Actor,
            ctx: &mut <Self::Actor as Actor>::Context
        ) -> Result<Async<Option<Self::Item>>, Self::Error>;

        fn map<U, F>(self, f: F) -> StreamMap<Self, F>
        where
            F: FnMut(Self::Item, &mut Self::Actor, &mut <Self::Actor as Actor>::Context) -> U,
        { ... }
        fn map_err<E, F>(self, f: F) -> StreamMapErr<Self, F>
        where
            F: FnMut(Self::Error, &mut Self::Actor, &mut <Self::Actor as Actor>::Context) -> E,
        { ... }
        fn then<F, U>(self, f: F) -> StreamThen<Self, F, U>
        where
            F: FnMut(Result<Self::Item, Self::Error>, &mut Self::Actor, &mut <Self::Actor as Actor>::Context) -> U,
            U: IntoActorFuture<Actor = Self::Actor>,
        { ... }
        fn and_then<F, U>(self, f: F) -> StreamAndThen<Self, F, U>
        where
            F: FnMut(Self::Item, &mut Self::Actor, &mut <Self::Actor as Actor>::Context) -> U,
            U: IntoActorFuture<Error = Self::Error, Actor = Self::Actor>,
        { ... }
        fn fold<F, T, Fut>(self, init: T, f: F) -> StreamFold<Self, F, Fut, T>
        where
            F: FnMut(T, Self::Item, &mut Self::Actor, &mut <Self::Actor as Actor>::Context) -> Fut,
            Fut: IntoActorFuture<Actor = Self::Actor, Item = T>,
            Self::Error: From<<Fut as IntoActorFuture>::Error>,
        { ... }
        fn timeout(self, timeout: Duration, err: Self::Error) -> StreamTimeout<Self>
        where
            Self::Error: Clone,
        { ... }
        fn finish(self) -> StreamFinish<Self> { ... }
    }

A stream of values, not all of which may have been produced yet.

This is similar to `futures::Stream` trait, except it works with `Actor`

## Associated Types

### `type Item`

The type of item this stream will yield on success.

### `type Error`

The type of error this stream may generate.

### `type Actor: Actor`

The actor within which this stream runs.

## Required Methods

### `fn poll(
&mut self,
srv: &mut Self::Actor,
ctx: &mut <Self::Actor as Actor>::Context
) -> Result<Async<Option<Self::Item>>, Self::Error>`

## Provided Methods

### `fn map<U, F>(self, f: F) -> StreamMap<Self, F> where
F: FnMut(Self::Item, &mut Self::Actor, &mut <Self::Actor as Actor>::Context) -> U,`

Converts a stream of type `T` to a stream of type `U`.

### `fn map_err<E, F>(self, f: F) -> StreamMapErr<Self, F> where
F: FnMut(Self::Error, &mut Self::Actor, &mut <Self::Actor as Actor>::Context) -> E,`

Converts a stream of error type `T` to a stream of error type `E`.

### `fn then<F, U>(self, f: F) -> StreamThen<Self, F, U> where
F: FnMut(Result<Self::Item, Self::Error>, &mut Self::Actor, &mut <Self::Actor as Actor>::Context) -> U,
U: IntoActorFuture<Actor = Self::Actor>,`

Chain on a computation for when a value is ready, passing the resulting item to the provided closure `f`.

### `fn and_then<F, U>(self, f: F) -> StreamAndThen<Self, F, U> where
F: FnMut(Self::Item, &mut Self::Actor, &mut <Self::Actor as Actor>::Context) -> U,
U: IntoActorFuture<Error = Self::Error, Actor = Self::Actor>,`

Chain on a computation for when a value is ready, passing the successful results to the provided closure `f`.

### `fn fold<F, T, Fut>(self, init: T, f: F) -> StreamFold<Self, F, Fut, T> where
F: FnMut(T, Self::Item, &mut Self::Actor, &mut <Self::Actor as Actor>::Context) -> Fut,
Fut: IntoActorFuture<Actor = Self::Actor, Item = T>,
Self::Error: From<<Fut as IntoActorFuture>::Error>,`

Execute an accumulating computation over a stream, collecting all the values into one final result.

### `fn timeout(self, timeout: Duration, err: Self::Error) -> StreamTimeout<Self> where
Self::Error: Clone,`

Add timeout to stream.

`err` value get returned as a timeout error.

### `fn finish(self) -> StreamFinish<Self>`

Converts a stream to a future that resolves when stream finishes.

## Implementors

- `impl<S, F, U> ActorStream for StreamMapErr<S, F> where F: FnMut(<S as ActorStream>::Error, &mut <S as ActorStream>::Actor, &mut <<S as ActorStream>::Actor as Actor>::Context) -> U, S: ActorStream, type Item = <S as ActorStream>::Item; type Error = U; type Actor = <S as ActorStream>::Actor;` |

- `impl<S, A> ActorStream for StreamWrap<S, A> where A: Actor, S: Stream, type Item = <S as Stream>::Item; type Error = <S as Stream>::Error; type Actor = A;` |

- `impl<S, F, U> ActorStream for StreamThen<S, F, U> where F: FnMut(Result<<S as ActorStream>::Item, <S as ActorStream>::Error>, &mut <S as ActorStream>::Actor, &mut <<S as ActorStream>::Actor as Actor>::Context) -> U, S: ActorStream, U: IntoActorFuture<Actor = <S as ActorStream>::Actor>, type Item = <U as IntoActorFuture>::Item; type Error = <U as IntoActorFuture>::Error; type Actor = <S as ActorStream>::Actor;` |

- `impl<S> ActorStream for StreamTimeout<S> where S: ActorStream, <S as ActorStream>::Error: Clone, type Item = <S as ActorStream>::Item; type Error = <S as ActorStream>::Error; type Actor = <S as ActorStream>::Actor;` |

- `impl<S, F, U> ActorStream for StreamMap<S, F> where F: FnMut(<S as ActorStream>::Item, &mut <S as ActorStream>::Actor, &mut <<S as ActorStream>::Actor as Actor>::Context) -> U, S: ActorStream, type Item = U; type Error = <S as ActorStream>::Error; type Actor = <S as ActorStream>::Actor;` |

- `impl<S, F, U> ActorStream for StreamAndThen<S, F, U> where F: FnMut(<S as ActorStream>::Item, &mut <S as ActorStream>::Actor, &mut <<S as ActorStream>::Actor as Actor>::Context) -> U, S: ActorStream, U: IntoActorFuture<Actor = <S as ActorStream>::Actor, Error = <S as ActorStream>::Error>, type Item = <U as IntoActorFuture>::Item; type Error = <S as ActorStream>::Error; type Actor = <S as ActorStream>::Actor;` |

# Help

## Keyboard Shortcuts

`?`
  Show this help dialog
`S`
  Focus the search field
`↑`
  Move up in search results
`↓`
  Move down in search results
`↹`
  Switch tab
`⏎`
  Go to active search result
`+`
  Expand all sections
`-`
  Collapse all sections

## Search Tricks

Prefix searches with a type followed by a colon (e.g. `fn:`) to restrict the search to a given type.

Accepted types are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.

Search functions by type signature (e.g. `vec -> usize` or `* -> vec`)

Search multiple things at once by splitting your query with comma (e.g. `str,u8` or `String,struct:Vec,test`)