Struct inquire::CustomType

pub struct CustomType<'a, T> {
    pub message: &'a str,
    pub default: Option<(T, CustomTypeFormatter<'a, T>)>,
    pub placeholder: Option<&'a str>,
    pub help_message: Option<&'a str>,
    pub formatter: CustomTypeFormatter<'a, T>,
    pub parser: CustomTypeParser<'a, T>,
    pub error_message: String,
    pub render_config: RenderConfig,
}

Generic prompt suitable for when you need to parse the user input into a specific type, for example an f64 or a rust_decimal, maybe even an uuid.

This prompt has all of the validation, parsing and error handling features built-in to reduce as much boilerplaste as possible from your prompts. Its defaults are necessarily very simple in order to cover a large range of generic cases, for example a “Invalid input” error message.

You can customize as many aspects of this prompt as you like: prompt message, help message, default value, placeholder, value parser and value formatter.

Behavior

When initializing this prompt via the new() method, some constraints on the return type T are added to make sure we can apply a default parser and formatter to the prompt.

The default parser calls the str.parse method, which means that T must implement the FromStr trait. When the parsing fails for any reason, a default error message “Invalid input” is displayed to the user.

After the user submits, the prompt handler tries to parse the input into the expected type. If the operation succeeds, the value is returned to the prompt caller. If it fails, the message defined in error_message is displayed to the user.

The default formatter simply calls to_string() on the parsed value, which means that T must implement the ToString trait, which normally happens implicitly when you implement the Display trait.

If your type T does not satisfy these constraints, you can always manually instantiate the entire struct yourself like this:

use inquire::{CustomType, ui::RenderConfig};

let amount_prompt: CustomType<f64> = CustomType {
    message: "How much is your travel going to cost?",
    formatter: &|i| format!("${:.2}", i),
    default: None,
    placeholder: Some("123.45"),
    error_message: "Please type a valid number.".into(),
    help_message: "Do not use currency and the number should use dots as the decimal separator.".into(),
    parser: &|i| match i.parse::<f64>() {
        Ok(val) => Ok(val),
        Err(_) => Err(()),
    },
    render_config: RenderConfig::default(),
};

Example

use inquire::CustomType;

let amount = CustomType::<f64>::new("How much do you want to donate?")
    .with_formatter(&|i| format!("${:.2}", i))
    .with_error_message("Please type a valid number")
    .with_help_message("Type the amount in US dollars using a decimal point as a separator")
    .prompt();

match amount {
    Ok(_) => println!("Thanks a lot for donating that much money!"),
    Err(_) => println!("We could not process your donation"),
}

Fields

message: &'a str

Message to be presented to the user.

default: Option<(T, CustomTypeFormatter<'a, T>)>

Default value, returned when the user input is empty.

placeholder: Option<&'a str>

Short hint that describes the expected value of the input.

help_message: Option<&'a str>

Help message to be presented to the user.

formatter: CustomTypeFormatter<'a, T>

Function that formats the user input and presents it to the user as the final rendering of the prompt.

parser: CustomTypeParser<'a, T>

Function that parses the user input and returns the result value.

error_message: String

Error message displayed when value could not be parsed from input.

render_config: RenderConfig

RenderConfig to apply to the rendered interface.

Note: The default render config considers if the NO_COLOR environment variable is set to decide whether to render the colored config or the empty one.

When overriding the config in a prompt, NO_COLOR is no longer considered and your config is treated as the only source of truth. If you want to customize colors and still suport NO_COLOR, you will have to do this on your end.

Implementations

impl<'a, T> CustomType<'a, T> where
    T: Clone, 

pub fn new(message: &'a str) -> Self where
    T: FromStr + ToString, 

Creates a CustomType with the provided message and default configuration values.

pub fn with_default(self, default: (T, CustomTypeFormatter<'a, T>)) -> Self

Sets the default input.

pub fn with_placeholder(self, placeholder: &'a str) -> Self

Sets the placeholder.

pub fn with_help_message(self, message: &'a str) -> Self

Sets the help message of the prompt.

pub fn with_formatter(self, formatter: CustomTypeFormatter<'a, T>) -> Self

Sets the formatter

pub fn with_parser(self, parser: CustomTypeParser<'a, T>) -> Self

Sets the parser.

pub fn with_error_message(self, error_message: &'a str) -> Self

Sets a custom error message displayed when a submission could not be parsed to a value.

pub fn with_render_config(self, render_config: RenderConfig) -> Self

Sets the provided color theme to this prompt.

Note: The default render config considers if the NO_COLOR environment variable is set to decide whether to render the colored config or the empty one.

When overriding the config in a prompt, NO_COLOR is no longer considered and your config is treated as the only source of truth. If you want to customize colors and still suport NO_COLOR, you will have to do this on your end.

pub fn prompt_skippable(self) -> InquireResult<Option<T>>

Parses the provided behavioral and rendering options and prompts the CLI user for input according to the defined rules.

This method is intended for flows where the user skipping/cancelling the prompt - by pressing ESC - is considered normal behavior. In this case, it does not return Err(InquireError::OperationCanceled), but Ok(None).

Meanwhile, if the user does submit an answer, the method wraps the return type with Some.

pub fn prompt(self) -> InquireResult<T>

Parses the provided behavioral and rendering options and prompts the CLI user for input according to the defined rules.

Trait Implementations

impl<'a, T: Clone> Clone for CustomType<'a, T>

fn clone(&self) -> CustomType<'a, T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> From<Confirm<'a>> for CustomType<'a, bool>

fn from(co: Confirm<'a>) -> Self

Performs the conversion.