Let's rethink defaults, and how they're specified

[EvanCarroll]

Problem

When a struct implements Default and is also used as CLI arguments, there's no way to reference the Default implementation's field values in #[arg(default_value_t = ...)]. This forces duplication via intermediate constants.

Minimal Example

use clap::Parser;

// Domain struct with Default implementation
#[derive(Default)]
struct Config {
    enabled: bool,
    timeout: u32,
}

impl Default for Config {
    fn default() -> Self {
        Self {
            enabled: true,
            timeout: 30,
        }
    }
}

// CLI needs to duplicate these defaults
#[derive(Parser)]
struct Cli {
    // ❌ Can't do this:
    // #[arg(long, default_value_t = Config::default().enabled)]

    // ✅ Currently forced to do this:
    #[arg(long, default_value_t = true)]  // Duplicated!
    enabled: bool,

    #[arg(long, default_value_t = 30)]    // Duplicated!
    timeout: u32,
}

Current Workaround

Create constants as a proxy:

  const DEFAULT_ENABLED: bool = true;
  const DEFAULT_TIMEOUT: u32 = 30;

  impl Default for Config {
      fn default() -> Self {
          Self {
              enabled: DEFAULT_ENABLED,
              timeout: DEFAULT_TIMEOUT,
          }
      }
  }

  #[derive(Parser)]
  struct Cli {
      #[arg(long, default_value_t = DEFAULT_ENABLED)]
      enabled: bool,
      #[arg(long, default_value_t = DEFAULT_TIMEOUT)]
      timeout: u32,
  }

This is verbose and without it it's error-prone when defaults change.

Requested Feature

Syntactic sugar to reference a struct's Default implementation:

  #[derive(Parser)]
  struct Cli {
      #[arg(long, default_from = Config::default().enabled)]
      enabled: bool,

      // Or simpler macro syntax:
      #[arg(long, default_from_field(Config, enabled))]
      enabled: bool,
  }

This ensures single source of truth for default values shared between domain logic and CLI.

In my application I have a command.

command subcommand --id x --foo
command subcommand --id x --foo

And I have another command

batch --batch-file foo.txt

I want the batching command to share the same defaults as the subcommands above. I don't believe this should require external constants linking the default and the clap definition of the arguments for the subcommand. The defaults are already on a struct.

[epage]

FYI #3116 is the issue where we are discussing this