Struct tide::head::Named

pub struct Named<T: NamedSegment>(pub T);

An extractor for named path segments

Allows routes to access named path segments ({foo}). Each Named<T> extracts a single segment. T must implement the NamedSegment trait - to provide the segment name - and the FromStr trait. Fails with a BAD_REQUEST response if the segment is not found, fails to parse or if multiple identically named segments exist.

Examples

Extracting a Number from a named path segment with:

use tide::head;
use tide::head::{Named, NamedSegment};

struct Number(i32);

impl NamedSegment for Number {
    const NAME: &'static str = "num";
}

impl std::str::FromStr for Number {
    type Err = std::num::ParseIntError;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        s.parse().map(|num| Number(num))
    }
}

async fn named_segments(Named(number): Named<Number>) -> String {
    let Number(num) = number;
    format!("number: {}", num)
}

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

Trait Implementations

impl<T: NamedSegment, S: 'static> Extract<S> for Named<T>

type Fut = Ready<Result<Self, Response>>

The async result of extract.

fn extract(     data: &mut S,     req: &mut Request,     params: &Option<RouteMatch>,     store: &Store ) -> Self::Fut

Attempt to extract a value from the given request.

impl<T: NamedSegment> DerefMut for Named<T>

fn deref_mut(&mut self) -> &mut T

Mutably dereferences the value.

impl<T: NamedSegment> Deref for Named<T>

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &T

Dereferences the value.