Struct Input

pub struct Input<'a, T> { /* private fields */ }

Renders an input prompt.

Example

use dialoguer::Input;

fn main() {
    let name: String = Input::new()
        .with_prompt("Your name?")
        .interact_text()
        .unwrap();

    println!("Your name is: {}", name);
}

It can also be used with turbofish notation:

use dialoguer::Input;

fn main() {
    let name = Input::<String>::new()
        .with_prompt("Your name?")
        .interact_text()
        .unwrap();

    println!("Your name is: {}", name);
}

Implementations

impl<T> Input<'_, T>

pub fn new() -> Self

Creates an input prompt with default theme.

pub fn with_prompt<S: Into<String>>(self, prompt: S) -> Self

Sets the input prompt.

pub fn with_post_completion_text<S: Into<String>>( self, post_completion_text: S, ) -> Self

Changes the prompt text to the post completion text after input is complete

pub fn report(self, val: bool) -> Self

Indicates whether to report the input value after interaction.

The default is to report the input value.

pub fn with_initial_text<S: Into<String>>(self, val: S) -> Self

Sets initial text that user can accept or erase.

pub fn default(self, value: T) -> Self

Sets a default.

Out of the box the prompt does not have a default and will continue to display until the user inputs something and hits enter. If a default is set the user can instead accept the default with enter.

pub fn allow_empty(self, val: bool) -> Self

Enables or disables an empty input

By default, if there is no default value set for the input, the user must input a non-empty string.

pub fn show_default(self, val: bool) -> Self

Disables or enables the default value display.

The default behaviour is to append default to the prompt to tell the user what is the default value.

This method does not affect existence of default value, only its display in the prompt!

impl<'a, T> Input<'a, T>

pub fn with_theme(theme: &'a dyn Theme) -> Self

Creates an input prompt with a specific theme.

Example

use dialoguer::{theme::ColorfulTheme, Input};

fn main() {
    let name: String = Input::with_theme(&ColorfulTheme::default())
        .interact()
        .unwrap();
}

impl<'a, T> Input<'a, T>

where T: 'a,

pub fn validate_with<V>(self, validator: V) -> Self

where V: InputValidator<T> + 'a, V::Err: ToString,

Registers a validator.

Example

use dialoguer::Input;

fn main() {
    let mail: String = Input::new()
        .with_prompt("Enter email")
        .validate_with(|input: &String| -> Result<(), &str> {
            if input.contains('@') {
                Ok(())
            } else {
                Err("This is not a mail address")
            }
        })
        .interact()
        .unwrap();
}

impl<T> Input<'_, T>

where T: Clone + ToString + FromStr, <T as FromStr>::Err: ToString,

pub fn interact_text(self) -> Result<T>

Enables the user to enter a printable ascii sequence and returns the result.

Its difference from interact is that it only allows ascii characters for string, while interact allows virtually any character to be used e.g arrow keys.

The dialog is rendered on stderr.

pub fn interact_text_on(self, term: &Term) -> Result<T>

Like interact_text but allows a specific terminal to be set.

pub fn interact(self) -> Result<T>

Enables user interaction and returns the result.

Allows any characters as input, including e.g arrow keys. Some of the keys might have undesired behavior. For more limited version, see interact_text.

If the user confirms the result is true, false otherwise. The dialog is rendered on stderr.

pub fn interact_on(self, term: &Term) -> Result<T>

Like interact but allows a specific terminal to be set.

Trait Implementations

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

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T> Default for Input<'static, T>

fn default() -> Self

Returns the “default value” for a type.