# Trait futures::future::IntoFuture [−] [src]

    pub trait IntoFuture {
        type Future: Future<Item = Self::Item, Error = Self::Error>;
        type Item;
        type Error;
        fn into_future(self) -> Self::Future;
    }

Class of types which can be converted into a future.

This trait is very similar to the `IntoIterator` trait and is intended to be used in a very similar fashion.

## Associated Types

### `type Future: Future<Item = Self::Item, Error = Self::Error>`

The future that this type can be converted into.

### `type Item`

The item that the future may resolve with.

### `type Error`

The error that the future may resolve with.

## Required Methods

### `fn into_future(self) -> Self::Future`

Consumes this object and produces a future.

## Implementations on Foreign Types

### `impl<A, B> IntoFuture for (A, B) where
A: IntoFuture,
B: IntoFuture<Error = A::Error>,`
[src]

#### `type Future = Join<A::Future, B::Future>`

#### `type Item = (A::Item, B::Item)`

#### `type Error = A::Error`

#### `fn into_future(self) -> Self::Future`
[src]

### `impl<A, B, C> IntoFuture for (A, B, C) where
A: IntoFuture,
B: IntoFuture<Error = A::Error>,
C: IntoFuture<Error = A::Error>,`
[src]

#### `type Future = Join3<A::Future, B::Future, C::Future>`

#### `type Item = (A::Item, B::Item, C::Item)`

#### `type Error = A::Error`

#### `fn into_future(self) -> Self::Future`
[src]

### `impl<A, B, C, D> IntoFuture for (A, B, C, D) where
A: IntoFuture,
B: IntoFuture<Error = A::Error>,
C: IntoFuture<Error = A::Error>,
D: IntoFuture<Error = A::Error>,`
[src]

#### `type Future = Join4<A::Future, B::Future, C::Future, D::Future>`

#### `type Item = (A::Item, B::Item, C::Item, D::Item)`

#### `type Error = A::Error`

#### `fn into_future(self) -> Self::Future`
[src]

### `impl<A, B, C, D, E> IntoFuture for (A, B, C, D, E) where
A: IntoFuture,
B: IntoFuture<Error = A::Error>,
C: IntoFuture<Error = A::Error>,
D: IntoFuture<Error = A::Error>,
E: IntoFuture<Error = A::Error>,`
[src]

#### `type Future = Join5<A::Future, B::Future, C::Future, D::Future, E::Future>`

#### `type Item = (A::Item, B::Item, C::Item, D::Item, E::Item)`

#### `type Error = A::Error`

#### `fn into_future(self) -> Self::Future`
[src]

### `impl<T, E> IntoFuture for Result<T, E>`
[src]

#### `type Future = FutureResult<T, E>`

#### `type Item = T`

#### `type Error = E`

#### `fn into_future(self) -> FutureResult<T, E>`
[src]

## Implementors

- [src]
  `impl<F: Future> IntoFuture for F type Future = F; type Item = F::Item; type Error = F::Error;`

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