Struct SimpleFnHandler 

pub struct SimpleFnHandler<F, T, R = HandlerResult<T>>
where
    T: Serialize,
{ /* 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 mut 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: FnMut(&ArgMatches) -> R, R: IntoHandlerResult<T>, T: Serialize,

pub fn new(f: F) -> Self

Creates a new SimpleFnHandler wrapping the given FnMut closure.

Trait Implementations

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

where F: FnMut(&ArgMatches) -> R, R: IntoHandlerResult<T>, T: Serialize,

type Output = T

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

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

Execute the handler with the given matches and context.

fn expected_args(&self) -> Vec<ExpectedArg>

Returns the arguments expected by this handler for verification.