arg::args_view(state),

        arg::sidebar(&state),

use clap::Parser;

use clap::{Parser, Subcommand};

    // Subcommand
    #[command(subcommand)]
    subcommand: Option<Subcmd>,
}
#[derive(Subcommand, Debug, Clone, Copy)]
pub enum Subcmd {
    /// First subcommand
    ///
    /// This explanation is also quite long.
    /// It takes up multiple lines
    One {
        #[arg(long)]
        times: u32,
    },
    /// Second subcommand
    ///
    /// Another, even longer explanation.
    /// Would it not be crazy
    /// if this took up 3 lines??
    Two {
        #[arg(short = 'a', long)]
        amount: i64,
    },

use clap::{Arg, ArgMatches, ValueHint};

use clap::{Arg, ArgMatches, Command, ValueHint};

fn source(state: &AppState, arg: &Arg) -> impl View<Arg> + ViewMarker {
    el::span(if let Ok(arg_matches) = state.arg_matches.as_ref() {

fn source(arg_matches: Option<&ArgMatches>, arg: &Arg) -> impl View<Arg> + ViewMarker {
    el::span(if let Some(arg_matches) = arg_matches.as_ref() {

fn matched_values(state: &AppState, arg: &Arg) -> impl View<Arg> + ViewMarker {

fn matched_values(arg_matches: Option<&ArgMatches>, arg: &Arg) -> impl View<Arg> + ViewMarker {

    let arg_matches = state.arg_matches.as_ref().unwrap_or(&default_matches);

    let arg_matches = arg_matches.unwrap_or(&default_matches);

fn item(state: &AppState, arg: &Arg) -> impl View<Arg> + ViewMarker {

fn item(arg_matches: Option<&ArgMatches>, arg: &Arg) -> impl View<Arg> + ViewMarker {

        source(state, arg),

        source(arg_matches, arg),

        matched_values(state, arg),

        matched_values(arg_matches, arg),

pub fn args_view(state: &mut AppState) -> impl View<AppState> + ViewMarker {
    el::div(

fn args_view(command: &Command, arg_matches: Option<&ArgMatches>) -> impl ViewSequence<AppState> {
    command
        .get_opts()
        .map(|arg| {
            Adapt::new(
                |_state, _thunk| {
                    // TODO: actually re-compute this value
                    MessageResult::Nop
                },
                item(arg_matches, arg),
            )
        })
        .collect::<Vec<_>>()
}
pub fn sidebar(state: &AppState) -> impl View<AppState> + ViewMarker {
    let arg_matches = state.arg_matches.as_ref().ok();
    el::div((
        args_view(&state.command, arg_matches),

            .get_opts()
            .map(|arg| {
                Adapt::new(
                    |_state, _thunk| {
                        // TODO: actually re-compute this value
                        MessageResult::Nop
                    },
                    item(state, arg),

            .get_subcommands()
            .map(|subcommand| {
                args_view(
                    subcommand,
                    arg_matches.and_then(|arg_matches| {
                        arg_matches.subcommand_matches(subcommand.get_name())
                    }),

    )

    ))