Trait tide::Endpoint

pub trait Endpoint<Data, Kind>: Send + Sync + 'static {
    type Fut: Future<Output = Response> + Send + 'static;
    fn call(
        &self, 
        data: Data, 
        req: Request, 
        params: Option<RouteMatch>, 
        store: &Store
    ) -> Self::Fut;
}

The raw representation of an endpoint.

This trait is automatically implemented by a host of Fn types, and should not be implemented directly by Tide users.

Examples

Endpoints are implemented as asynchronous functions that make use of language features currently only available in Rust Nightly. For this reason, we have to explicitly enable those features with #![feature(async_await, futures_api)]. To keep examples concise, the attribute will be omitted in most of the documentation.

A simple endpoint that is invoked on a GET request and returns a String:

async fn hello() -> String {
    String::from("hello")
}

fn main() {
    let mut app = tide::App::new(());
    app.at("/hello").get(hello);
    app.serve()
}

Endpoint accessing App state (Data) and body of POST request as String:

use std::sync::Arc;
use std::sync::Mutex;
use tide::AppData;
use tide::body;

#[derive(Clone, Default)]
struct Database {
    contents: Arc<Mutex<Vec<String>>>,
}

async fn insert(
    mut db: AppData<Database>,
    msg: body::Str,
) -> String {
    // insert into db
}

fn main() {
    let mut app = tide::App::new(Database::default());
    app.at("/messages/insert").post(insert);
    app.serve()
}

See body module for examples of how to work with request and response bodies.

Associated Types

type Fut: Future<Output = Response> + Send + 'static

The async result of call.

Loading content...

Required methods

fn call(
    &self,
    data: Data,
    req: Request,
    params: Option<RouteMatch>,
    store: &Store
) -> Self::Fut

Invoke the endpoint on the given request and app data handle.

Loading content...

Implementors

impl<T, Data, Fut> Endpoint<Data, (Ty<Fut>, Head)> for T where
    T: Send + Sync + Clone + 'static + Fn(Head) -> Fut,
    Data: Clone + Send + Sync + 'static,
    Fut: Future + Send + 'static,
    Fut::Output: IntoResponse, 

type Fut = FutureObj<'static, Response>

fn call(
    &self,
    data: Data,
    req: Request,
    params: Option<RouteMatch>,
    store: &Store
) -> Self::Fut

impl<T, Data, Fut> Endpoint<Data, (Ty<Fut>,)> for T where
    T: Send + Sync + Clone + 'static + Fn() -> Fut,
    Data: Clone + Send + Sync + 'static,
    Fut: Future + Send + 'static,
    Fut::Output: IntoResponse, 

type Fut = FutureObj<'static, Response>

fn call(
    &self,
    data: Data,
    req: Request,
    params: Option<RouteMatch>,
    store: &Store
) -> Self::Fut

impl<T, Data, Fut, T0> Endpoint<Data, (Ty<Fut>, Head, Ty<T0>)> for T where
    T: Send + Sync + Clone + 'static + Fn(Head, T0) -> Fut,
    Data: Clone + Send + Sync + 'static,
    Fut: Future + Send + 'static,
    Fut::Output: IntoResponse,
    T0: Extract<Data>, 

type Fut = FutureObj<'static, Response>

fn call(
    &self,
    data: Data,
    req: Request,
    params: Option<RouteMatch>,
    store: &Store
) -> Self::Fut

impl<T, Data, Fut, T0> Endpoint<Data, (Ty<Fut>, Ty<T0>)> for T where
    T: Send + Sync + Clone + 'static + Fn(T0) -> Fut,
    Data: Clone + Send + Sync + 'static,
    Fut: Future + Send + 'static,
    Fut::Output: IntoResponse,
    T0: Extract<Data>, 

type Fut = FutureObj<'static, Response>

fn call(
    &self,
    data: Data,
    req: Request,
    params: Option<RouteMatch>,
    store: &Store
) -> Self::Fut

impl<T, Data, Fut, T0, T1> Endpoint<Data, (Ty<Fut>, Head, Ty<T0>, Ty<T1>)> for T where
    T: Send + Sync + Clone + 'static + Fn(Head, T0, T1) -> Fut,
    Data: Clone + Send + Sync + 'static,
    Fut: Future + Send + 'static,
    Fut::Output: IntoResponse,
    T0: Extract<Data>,
    T1: Extract<Data>, 

type Fut = FutureObj<'static, Response>

fn call(
    &self,
    data: Data,
    req: Request,
    params: Option<RouteMatch>,
    store: &Store
) -> Self::Fut

impl<T, Data, Fut, T0, T1> Endpoint<Data, (Ty<Fut>, Ty<T0>, Ty<T1>)> for T where
    T: Send + Sync + Clone + 'static + Fn(T0, T1) -> Fut,
    Data: Clone + Send + Sync + 'static,
    Fut: Future + Send + 'static,
    Fut::Output: IntoResponse,
    T0: Extract<Data>,
    T1: Extract<Data>, 

type Fut = FutureObj<'static, Response>

fn call(
    &self,
    data: Data,
    req: Request,
    params: Option<RouteMatch>,
    store: &Store
) -> Self::Fut

impl<T, Data, Fut, T0, T1, T2> Endpoint<Data, (Ty<Fut>, Head, Ty<T0>, Ty<T1>, Ty<T2>)> for T where
    T: Send + Sync + Clone + 'static + Fn(Head, T0, T1, T2) -> Fut,
    Data: Clone + Send + Sync + 'static,
    Fut: Future + Send + 'static,
    Fut::Output: IntoResponse,
    T0: Extract<Data>,
    T1: Extract<Data>,
    T2: Extract<Data>, 

type Fut = FutureObj<'static, Response>

fn call(
    &self,
    data: Data,
    req: Request,
    params: Option<RouteMatch>,
    store: &Store
) -> Self::Fut

impl<T, Data, Fut, T0, T1, T2> Endpoint<Data, (Ty<Fut>, Ty<T0>, Ty<T1>, Ty<T2>)> for T where
    T: Send + Sync + Clone + 'static + Fn(T0, T1, T2) -> Fut,
    Data: Clone + Send + Sync + 'static,
    Fut: Future + Send + 'static,
    Fut::Output: IntoResponse,
    T0: Extract<Data>,
    T1: Extract<Data>,
    T2: Extract<Data>, 

type Fut = FutureObj<'static, Response>

fn call(
    &self,
    data: Data,
    req: Request,
    params: Option<RouteMatch>,
    store: &Store
) -> Self::Fut

impl<T, Data, Fut, T0, T1, T2, T3> Endpoint<Data, (Ty<Fut>, Head, Ty<T0>, Ty<T1>, Ty<T2>, Ty<T3>)> for T where
    T: Send + Sync + Clone + 'static + Fn(Head, T0, T1, T2, T3) -> Fut,
    Data: Clone + Send + Sync + 'static,
    Fut: Future + Send + 'static,
    Fut::Output: IntoResponse,
    T0: Extract<Data>,
    T1: Extract<Data>,
    T2: Extract<Data>,
    T3: Extract<Data>, 

type Fut = FutureObj<'static, Response>

fn call(
    &self,
    data: Data,
    req: Request,
    params: Option<RouteMatch>,
    store: &Store
) -> Self::Fut

impl<T, Data, Fut, T0, T1, T2, T3> Endpoint<Data, (Ty<Fut>, Ty<T0>, Ty<T1>, Ty<T2>, Ty<T3>)> for T where
    T: Send + Sync + Clone + 'static + Fn(T0, T1, T2, T3) -> Fut,
    Data: Clone + Send + Sync + 'static,
    Fut: Future + Send + 'static,
    Fut::Output: IntoResponse,
    T0: Extract<Data>,
    T1: Extract<Data>,
    T2: Extract<Data>,
    T3: Extract<Data>, 

type Fut = FutureObj<'static, Response>

fn call(
    &self,
    data: Data,
    req: Request,
    params: Option<RouteMatch>,
    store: &Store
) -> Self::Fut

impl<T, Data, Fut, T0, T1, T2, T3, T4> Endpoint<Data, (Ty<Fut>, Head, Ty<T0>, Ty<T1>, Ty<T2>, Ty<T3>, Ty<T4>)> for T where
    T: Send + Sync + Clone + 'static + Fn(Head, T0, T1, T2, T3, T4) -> Fut,
    Data: Clone + Send + Sync + 'static,
    Fut: Future + Send + 'static,
    Fut::Output: IntoResponse,
    T0: Extract<Data>,
    T1: Extract<Data>,
    T2: Extract<Data>,
    T3: Extract<Data>,
    T4: Extract<Data>, 

type Fut = FutureObj<'static, Response>

fn call(
    &self,
    data: Data,
    req: Request,
    params: Option<RouteMatch>,
    store: &Store
) -> Self::Fut

impl<T, Data, Fut, T0, T1, T2, T3, T4> Endpoint<Data, (Ty<Fut>, Ty<T0>, Ty<T1>, Ty<T2>, Ty<T3>, Ty<T4>)> for T where
    T: Send + Sync + Clone + 'static + Fn(T0, T1, T2, T3, T4) -> Fut,
    Data: Clone + Send + Sync + 'static,
    Fut: Future + Send + 'static,
    Fut::Output: IntoResponse,
    T0: Extract<Data>,
    T1: Extract<Data>,
    T2: Extract<Data>,
    T3: Extract<Data>,
    T4: Extract<Data>, 

type Fut = FutureObj<'static, Response>

fn call(
    &self,
    data: Data,
    req: Request,
    params: Option<RouteMatch>,
    store: &Store
) -> Self::Fut

impl<T, Data, Fut, T0, T1, T2, T3, T4, T5> Endpoint<Data, (Ty<Fut>, Head, Ty<T0>, Ty<T1>, Ty<T2>, Ty<T3>, Ty<T4>, Ty<T5>)> for T where
    T: Send + Sync + Clone + 'static + Fn(Head, T0, T1, T2, T3, T4, T5) -> Fut,
    Data: Clone + Send + Sync + 'static,
    Fut: Future + Send + 'static,
    Fut::Output: IntoResponse,
    T0: Extract<Data>,
    T1: Extract<Data>,
    T2: Extract<Data>,
    T3: Extract<Data>,
    T4: Extract<Data>,
    T5: Extract<Data>, 

type Fut = FutureObj<'static, Response>

fn call(
    &self,
    data: Data,
    req: Request,
    params: Option<RouteMatch>,
    store: &Store
) -> Self::Fut

impl<T, Data, Fut, T0, T1, T2, T3, T4, T5> Endpoint<Data, (Ty<Fut>, Ty<T0>, Ty<T1>, Ty<T2>, Ty<T3>, Ty<T4>, Ty<T5>)> for T where
    T: Send + Sync + Clone + 'static + Fn(T0, T1, T2, T3, T4, T5) -> Fut,
    Data: Clone + Send + Sync + 'static,
    Fut: Future + Send + 'static,
    Fut::Output: IntoResponse,
    T0: Extract<Data>,
    T1: Extract<Data>,
    T2: Extract<Data>,
    T3: Extract<Data>,
    T4: Extract<Data>,
    T5: Extract<Data>, 

type Fut = FutureObj<'static, Response>

fn call(
    &self,
    data: Data,
    req: Request,
    params: Option<RouteMatch>,
    store: &Store
) -> Self::Fut

impl<T, Data, Fut, T0, T1, T2, T3, T4, T5, T6> Endpoint<Data, (Ty<Fut>, Head, Ty<T0>, Ty<T1>, Ty<T2>, Ty<T3>, Ty<T4>, Ty<T5>, Ty<T6>)> for T where
    T: Send + Sync + Clone + 'static + Fn(Head, T0, T1, T2, T3, T4, T5, T6) -> Fut,
    Data: Clone + Send + Sync + 'static,
    Fut: Future + Send + 'static,
    Fut::Output: IntoResponse,
    T0: Extract<Data>,
    T1: Extract<Data>,
    T2: Extract<Data>,
    T3: Extract<Data>,
    T4: Extract<Data>,
    T5: Extract<Data>,
    T6: Extract<Data>, 

type Fut = FutureObj<'static, Response>

fn call(
    &self,
    data: Data,
    req: Request,
    params: Option<RouteMatch>,
    store: &Store
) -> Self::Fut

impl<T, Data, Fut, T0, T1, T2, T3, T4, T5, T6> Endpoint<Data, (Ty<Fut>, Ty<T0>, Ty<T1>, Ty<T2>, Ty<T3>, Ty<T4>, Ty<T5>, Ty<T6>)> for T where
    T: Send + Sync + Clone + 'static + Fn(T0, T1, T2, T3, T4, T5, T6) -> Fut,
    Data: Clone + Send + Sync + 'static,
    Fut: Future + Send + 'static,
    Fut::Output: IntoResponse,
    T0: Extract<Data>,
    T1: Extract<Data>,
    T2: Extract<Data>,
    T3: Extract<Data>,
    T4: Extract<Data>,
    T5: Extract<Data>,
    T6: Extract<Data>, 

type Fut = FutureObj<'static, Response>

fn call(
    &self,
    data: Data,
    req: Request,
    params: Option<RouteMatch>,
    store: &Store
) -> Self::Fut

impl<T, Data, Fut, T0, T1, T2, T3, T4, T5, T6, T7> Endpoint<Data, (Ty<Fut>, Head, Ty<T0>, Ty<T1>, Ty<T2>, Ty<T3>, Ty<T4>, Ty<T5>, Ty<T6>, Ty<T7>)> for T where
    T: Send + Sync + Clone + 'static + Fn(Head, T0, T1, T2, T3, T4, T5, T6, T7) -> Fut,
    Data: Clone + Send + Sync + 'static,
    Fut: Future + Send + 'static,
    Fut::Output: IntoResponse,
    T0: Extract<Data>,
    T1: Extract<Data>,
    T2: Extract<Data>,
    T3: Extract<Data>,
    T4: Extract<Data>,
    T5: Extract<Data>,
    T6: Extract<Data>,
    T7: Extract<Data>, 

type Fut = FutureObj<'static, Response>

fn call(
    &self,
    data: Data,
    req: Request,
    params: Option<RouteMatch>,
    store: &Store
) -> Self::Fut

impl<T, Data, Fut, T0, T1, T2, T3, T4, T5, T6, T7> Endpoint<Data, (Ty<Fut>, Ty<T0>, Ty<T1>, Ty<T2>, Ty<T3>, Ty<T4>, Ty<T5>, Ty<T6>, Ty<T7>)> for T where
    T: Send + Sync + Clone + 'static + Fn(T0, T1, T2, T3, T4, T5, T6, T7) -> Fut,
    Data: Clone + Send + Sync + 'static,
    Fut: Future + Send + 'static,
    Fut::Output: IntoResponse,
    T0: Extract<Data>,
    T1: Extract<Data>,
    T2: Extract<Data>,
    T3: Extract<Data>,
    T4: Extract<Data>,
    T5: Extract<Data>,
    T6: Extract<Data>,
    T7: Extract<Data>, 

type Fut = FutureObj<'static, Response>

fn call(
    &self,
    data: Data,
    req: Request,
    params: Option<RouteMatch>,
    store: &Store
) -> Self::Fut

impl<T, Data, Fut, T0, T1, T2, T3, T4, T5, T6, T7, T8> Endpoint<Data, (Ty<Fut>, Head, Ty<T0>, Ty<T1>, Ty<T2>, Ty<T3>, Ty<T4>, Ty<T5>, Ty<T6>, Ty<T7>, Ty<T8>)> for T where
    T: Send + Sync + Clone + 'static + Fn(Head, T0, T1, T2, T3, T4, T5, T6, T7, T8) -> Fut,
    Data: Clone + Send + Sync + 'static,
    Fut: Future + Send + 'static,
    Fut::Output: IntoResponse,
    T0: Extract<Data>,
    T1: Extract<Data>,
    T2: Extract<Data>,
    T3: Extract<Data>,
    T4: Extract<Data>,
    T5: Extract<Data>,
    T6: Extract<Data>,
    T7: Extract<Data>,
    T8: Extract<Data>, 

type Fut = FutureObj<'static, Response>

fn call(
    &self,
    data: Data,
    req: Request,
    params: Option<RouteMatch>,
    store: &Store
) -> Self::Fut

impl<T, Data, Fut, T0, T1, T2, T3, T4, T5, T6, T7, T8> Endpoint<Data, (Ty<Fut>, Ty<T0>, Ty<T1>, Ty<T2>, Ty<T3>, Ty<T4>, Ty<T5>, Ty<T6>, Ty<T7>, Ty<T8>)> for T where
    T: Send + Sync + Clone + 'static + Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8) -> Fut,
    Data: Clone + Send + Sync + 'static,
    Fut: Future + Send + 'static,
    Fut::Output: IntoResponse,
    T0: Extract<Data>,
    T1: Extract<Data>,
    T2: Extract<Data>,
    T3: Extract<Data>,
    T4: Extract<Data>,
    T5: Extract<Data>,
    T6: Extract<Data>,
    T7: Extract<Data>,
    T8: Extract<Data>, 

type Fut = FutureObj<'static, Response>

fn call(
    &self,
    data: Data,
    req: Request,
    params: Option<RouteMatch>,
    store: &Store
) -> Self::Fut

impl<T, Data, Fut, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Endpoint<Data, (Ty<Fut>, Head, Ty<T0>, Ty<T1>, Ty<T2>, Ty<T3>, Ty<T4>, Ty<T5>, Ty<T6>, Ty<T7>, Ty<T8>, Ty<T9>)> for T where
    T: Send + Sync + Clone + 'static + Fn(Head, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) -> Fut,
    Data: Clone + Send + Sync + 'static,
    Fut: Future + Send + 'static,
    Fut::Output: IntoResponse,
    T0: Extract<Data>,
    T1: Extract<Data>,
    T2: Extract<Data>,
    T3: Extract<Data>,
    T4: Extract<Data>,
    T5: Extract<Data>,
    T6: Extract<Data>,
    T7: Extract<Data>,
    T8: Extract<Data>,
    T9: Extract<Data>, 

type Fut = FutureObj<'static, Response>

fn call(
    &self,
    data: Data,
    req: Request,
    params: Option<RouteMatch>,
    store: &Store
) -> Self::Fut

impl<T, Data, Fut, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Endpoint<Data, (Ty<Fut>, Ty<T0>, Ty<T1>, Ty<T2>, Ty<T3>, Ty<T4>, Ty<T5>, Ty<T6>, Ty<T7>, Ty<T8>, Ty<T9>)> for T where
    T: Send + Sync + Clone + 'static + Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) -> Fut,
    Data: Clone + Send + Sync + 'static,
    Fut: Future + Send + 'static,
    Fut::Output: IntoResponse,
    T0: Extract<Data>,
    T1: Extract<Data>,
    T2: Extract<Data>,
    T3: Extract<Data>,
    T4: Extract<Data>,
    T5: Extract<Data>,
    T6: Extract<Data>,
    T7: Extract<Data>,
    T8: Extract<Data>,
    T9: Extract<Data>, 

type Fut = FutureObj<'static, Response>

fn call(
    &self,
    data: Data,
    req: Request,
    params: Option<RouteMatch>,
    store: &Store
) -> Self::Fut

Loading content...