Struct Execute 

pub struct Execute<E>(/* private fields */);

Wraps a function or closure as a Service.

Use Execute to turn any async function into a service without defining a custom type.

Examples

async fn handle_input(data: String) -> String {
    format!("Processed: {}", data)
}

let service = Execute::new(handle_input);
let result = service.execute("test".to_string()).await;
assert_eq!(result, "Processed: test");

let service = Execute::new(move |x: i32| async move { x * 2 });
let result = service.execute(5).await;
assert_eq!(result, 10);

Implementations

impl<E> Execute<E>

pub fn new<In, Out, F>(e: E) -> Self

where E: Fn(In) -> F + Send + Sync + 'static, In: Send + 'static, F: Future<Output = Out> + Send + 'static, Out: Send + 'static,

Creates a new service from a function or closure.

Examples

let service = Execute::new(|msg: String| async move { format!("Echo: {}", msg) });

Trait Implementations

impl<E: Clone> Clone for Execute<E>

fn clone(&self) -> Execute<E>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<E> Debug for Execute<E>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<E, F, In, Out> Service<In> for Execute<E>

where E: Fn(In) -> F + Send + Sync, F: Future<Output = Out> + Send,

type Out = Out

The output type returned by this service.

fn execute(&self, input: In) -> impl Future<Output = Self::Out> + Send

Processes the input and returns the output.

impl<E, F, Req, Res, Err> Service<Req> for Execute<E>

where E: Fn(Req) -> F + Send + Sync, F: Future<Output = Result<Res, Err>> + Send,

Available on crate features tower-service only.

type Response = Res

Responses given by the service.

type Error = Err

Errors produced by the service.

type Future = F

The future response value.

fn poll_ready(&mut self, _cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests.

fn call(&mut self, req: Req) -> Self::Future

Process the request and return the response asynchronously.