Enum FormError 

pub enum FormError {
    UserAborted,
    Timeout,
    Validation(String),
    Io(String),
}

Errors that can occur during form execution.

This enum represents all possible error conditions when running an interactive form with huh.

Error Handling

Forms can fail for several reasons, but many are recoverable or expected user actions (like cancellation):

use huh::{Form, FormError, Result};

fn get_user_input() -> Result<String> {
    let mut name = String::new();
    Form::new(fields)
        .run()?;
    Ok(name)
}

Recovery Strategies

Error Variant	Recovery Strategy
UserAborted	Normal exit, not an error condition
Timeout	Retry with longer timeout or prompt user
Validation	Show error message, allow retry
Io	Check terminal, fall back to non-interactive

Example: Handling User Abort

User abort (Ctrl+C) is a normal exit path, not an error:

match form.run() {
    Ok(()) => println!("Form completed!"),
    Err(FormError::UserAborted) => {
        println!("Cancelled by user");
        return Ok(()); // Not an error condition
    }
    Err(e) => return Err(e.into()),
}

Note on Clone and PartialEq

This error type implements Clone and PartialEq to support testing and comparison. As a result, the Io variant stores a String message rather than the underlying io::Error.

Variants

UserAborted

User aborted the form with Ctrl+C or Escape.

This is not an error condition but a normal exit path. Users may cancel forms for valid reasons, and applications should handle this gracefully.

Example

match form.run() {
    Err(FormError::UserAborted) => {
        println!("No changes made");
        return Ok(());
    }
    // ...
}

Timeout

Form execution timed out.

Occurs when a form has a timeout configured and the user does not complete it in time.

Recovery

• Increase the timeout duration
• Prompt user to try again
• Use a default value

Validation(String)

Custom validation error.

Occurs when a field’s validation function returns an error. The contained string describes what validation failed.

Recovery

Validation errors are recoverable - show the error message to the user and allow them to correct their input.

Example

let input = Input::new()
    .title("Email")
    .validate(|s| {
        if s.contains('@') {
            Ok(())
        } else {
            Err(FormError::Validation("must contain @".into()))
        }
    });

Io(String)

IO error during form operations.

Occurs during terminal I/O operations, particularly in accessible mode where stdin/stdout are used directly.

Note: Stores the error message as a String rather than io::Error to maintain Clone and PartialEq derives.

Recovery

• Check if the terminal is available
• Fall back to non-interactive input
• Log the error and exit gracefully

Implementations

impl FormError

pub fn validation(message: impl Into<String>) -> Self

Creates a validation error with the given message.

pub fn io(message: impl Into<String>) -> Self

Creates an IO error with the given message.

pub fn is_user_abort(&self) -> bool

Returns true if this is a user-initiated abort.

pub fn is_timeout(&self) -> bool

Returns true if this is a timeout error.

pub fn is_recoverable(&self) -> bool

Returns true if this error is recoverable (validation errors).

Trait Implementations

impl Clone for FormError

fn clone(&self) -> FormError

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for FormError

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Display for FormError

fn fmt(&self, __formatter: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Error for FormError

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0: use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0: replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type-based access to context intended for error reports.

impl PartialEq for FormError

fn eq(&self, other: &FormError) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for FormError

impl StructuralPartialEq for FormError