Struct finchers::endpoint::combinator::Map

pub struct Map<E, F> { /* fields omitted */ }

The return type of map(e, f)

Trait Implementations

impl<E: Debug, F: Debug> Debug for Map<E, F>

fn fmt(&self, __arg_0: &mut Formatter) -> Result

Formats the value using the given formatter.

impl<E, F, R> Endpoint for Map<E, F> where
    E: Endpoint,
    F: FnOnce(E::Item) -> R, 

type Item = R

The type of resolved value, created by this endpoint

type Error = E::Error

type Future = Map<E::Future, F>

The type of future created by this endpoint

fn apply(self, ctx: &mut Context) -> EndpointResult<Self::Future>

Apply the incoming HTTP request, and return the future of its response

fn join<E>(self, e: E) -> (Self, E) where
    Self: Sized,
    E: Endpoint<Error = Self::Error>, 

Combine itself and the other endpoint, and create a combinator which returns a pair of its Items.

fn join3<E1, E2>(self, e1: E1, e2: E2) -> (Self, E1, E2) where
    Self: Sized,
    E1: Endpoint<Error = Self::Error>,
    E2: Endpoint<Error = Self::Error>, 

Combine itself and two other endpoints, and create a combinator which returns a tuple of its Items.

fn join4<E1, E2, E3>(self, e1: E1, e2: E2, e3: E3) -> (Self, E1, E2, E3) where
    Self: Sized,
    E1: Endpoint<Error = Self::Error>,
    E2: Endpoint<Error = Self::Error>,
    E3: Endpoint<Error = Self::Error>, 

Combine itself and three other endpoints, and create a combinator which returns a tuple of its Items.

fn join5<E1, E2, E3, E4>(
    self,
    e1: E1,
    e2: E2,
    e3: E3,
    e4: E4
) -> (Self, E1, E2, E3, E4) where
    Self: Sized,
    E1: Endpoint<Error = Self::Error>,
    E2: Endpoint<Error = Self::Error>,
    E3: Endpoint<Error = Self::Error>,
    E4: Endpoint<Error = Self::Error>, 

Combine itself and four other endpoints, and create a combinator which returns a tuple of its Items.

fn with<E>(self, e: E) -> With<Self, E> where
    Self: Sized,
    E: Endpoint<Error = Self::Error>, 

Combine itself and the other endpoint, and create a combinator which returns E::Item.

fn skip<E>(self, e: E) -> Skip<Self, E> where
    Self: Sized,
    E: Endpoint<Error = Self::Error>, 

Combine itself and the other endpoint, and create a combinator which returns Self::Item.

fn or<E>(self, e: E) -> Or<Self, E> where
    Self: Sized,
    E: Endpoint<Item = Self::Item, Error = Self::Error>, 

Create an endpoint which attempts to apply self. If self failes, then revert the context and retry applying e.

fn map<F, U>(self, f: F) -> Map<Self, F> where
    Self: Sized,
    F: FnOnce(Self::Item) -> U, 

Combine itself and a function to change the return value to another type.

fn map_err<F, U>(self, f: F) -> MapErr<Self, F> where
    Self: Sized,
    F: FnOnce(Self::Error) -> U, 

Combine itself and a function to change the error value to another type.

fn and_then<F, Fut>(self, f: F) -> AndThen<Self, F> where
    Self: Sized,
    F: FnOnce(Self::Item) -> Fut,
    Fut: IntoFuture<Error = Self::Error>, 

fn or_else<F, Fut>(self, f: F) -> OrElse<Self, F> where
    Self: Sized,
    F: FnOnce(Self::Error) -> Fut,
    Fut: IntoFuture<Item = Self::Item>, 

fn then<F, Fut>(self, f: F) -> Then<Self, F> where
    Self: Sized,
    F: FnOnce(Result<Self::Item, Self::Error>) -> Fut,
    Fut: IntoFuture, 

fn from_err<T>(self) -> FromErr<Self, T> where
    Self: Sized,
    T: From<Self::Error>, 

fn inspect<F>(self, f: F) -> Inspect<Self, F> where
    Self: Sized,
    F: FnOnce(&Self::Item), 

fn with_type<T, E>(self) -> Self where
    Self: Sized + Endpoint<Item = T, Error = E>,