# actix_web::actix::actix::fut::ActorStream - Rust
API documentation for the Rust `ActorStream` trait in crate `actix_web`.
Keywords: rust, rustlang, rust-lang, ActorStream

# [−] Trait actix_web::actix::actix::fut::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<A> ActorStream for IntervalFunc<A> where A: Actor,`

#### `type Item = ()`

#### `type Error = ()`

#### `type Actor = A`

####

`fn poll( &mut self, act: &mut <IntervalFunc<A> as ActorStream>::Actor, ctx: &mut <<IntervalFunc<A> as ActorStream>::Actor as Actor>::Context ) -> Result<Async<Option<<IntervalFunc<A> as ActorStream>::Item>>, <IntervalFunc<A> as ActorStream>::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>` |

###

`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`

####

`fn poll( &mut self, act: &mut <S as ActorStream>::Actor, ctx: &mut <<S as ActorStream>::Actor as Actor>::Context ) -> Result<Async<Option<<S as ActorStream>::Item>>, <S as ActorStream>::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>` |

###

`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`

####

`fn poll( &mut self, &mut <StreamWrap<S, A> as ActorStream>::Actor, &mut <<StreamWrap<S, A> as ActorStream>::Actor as Actor>::Context ) -> Result<Async<Option<<StreamWrap<S, A> as ActorStream>::Item>>, <StreamWrap<S, A> as ActorStream>::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>` |

###

`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`

####

`fn poll( &mut self, act: &mut <S as ActorStream>::Actor, ctx: &mut <<S as ActorStream>::Actor as Actor>::Context ) -> Result<Async<Option<<U as IntoActorFuture>::Item>>, <S as ActorStream>::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>` |

###

`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`

####

`fn poll( &mut self, act: &mut <StreamMap<S, F> as ActorStream>::Actor, ctx: &mut <<S as ActorStream>::Actor as Actor>::Context ) -> Result<Async<Option<U>>, <S as ActorStream>::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>` |

###

`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`

####

`fn poll( &mut self, act: &mut <StreamMapErr<S, F> as ActorStream>::Actor, ctx: &mut <<S as ActorStream>::Actor as Actor>::Context ) -> Result<Async<Option<<S as ActorStream>::Item>>, U>` |

####

`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>` |

###

`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`

####

`fn poll( &mut self, act: &mut <S as ActorStream>::Actor, ctx: &mut <<S as ActorStream>::Actor as Actor>::Context ) -> Result<Async<Option<<U as IntoActorFuture>::Item>>, <U as IntoActorFuture>::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>` |

# 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`)