Struct SimpleFnHandler 

pub struct SimpleFnHandler<F, T, R = HandlerResult<T>>
where
    T: Serialize + Send + Sync,
{ /* private fields */ }

A handler wrapper for functions that don’t need CommandContext.

This is the simpler variant of FnHandler for handlers that only need ArgMatches. The context parameter is accepted but ignored internally.

The closure can return either:

• Result<T, E> - automatically wrapped in Output::Render
• HandlerResult<T> - passed through unchanged (for Output::Silent or Output::Binary)

Example

use standout_dispatch::{SimpleFnHandler, Handler, CommandContext, Output};
use clap::ArgMatches;

// Handler that doesn't need context - just uses ArgMatches
let handler = SimpleFnHandler::new(|_m: &ArgMatches| {
    Ok::<_, anyhow::Error>("Hello, world!".to_string())
});

// Can still be used via Handler trait (context is ignored)
let ctx = CommandContext::default();
let matches = clap::Command::new("test").get_matches_from(vec!["test"]);
let result = handler.handle(&matches, &ctx);
assert!(matches!(result, Ok(Output::Render(_))));

Implementations

impl<F, T, R> SimpleFnHandler<F, T, R>

where F: Fn(&ArgMatches) -> R + Send + Sync, R: IntoHandlerResult<T>, T: Serialize + Send + Sync,

pub fn new(f: F) -> Self

Creates a new SimpleFnHandler wrapping the given closure.

Trait Implementations

impl<F, T, R> Handler for SimpleFnHandler<F, T, R>

where F: Fn(&ArgMatches) -> R + Send + Sync, R: IntoHandlerResult<T>, T: Serialize + Send + Sync,

type Output = T

The output type produced by this handler (must be serializable)

fn handle( &self, matches: &ArgMatches, _ctx: &CommandContext, ) -> HandlerResult<T>

Execute the handler with the given matches and context.