enum Result<T, E> {
    Ok(T),
    Err(E),
}

fn read_config() -> Result<Config, io::Error> {
    letmut file = match File::open("config.toml") {
        Ok(f) => f,
        Err(e) => returnErr(e),
    };
    letmut contents = String::new();
    match file.read_to_string(&mut contents) {
        Ok(_) => (),
        Err(e) => returnErr(e),
    };
    match toml::from_str(&contents) {
        Ok(config) => Ok(config),
        Err(e) => Err(io::Error::new(io::ErrorKind::InvalidData, e)),
    }
}

fn read_config() -> Result<Config, Box<dyn Error>> {
    let mut file = File::open("config.toml")?;
    let mut contents = String::new();
    file.read_to_string(&mut contents)?;
    let config: Config = toml::from_str(&contents)?;
    Ok(config)
}

#[derive(Debug, thiserror::Error)]
enum AppError {
    #[error("I/O error: {0}")]
    Io(#[from] io::Error),
    
    #[error("Configuration error: {0}")]
    Config(#[from] toml::de::Error),
    
    #[error("Validation failed for field {field}: {reason}")]
    Validation {
        field: String,
        reason: String,
    },
}

use anyhow::{Context, Result};

fn process_data(path: &str) -> Result<()> {
    let data = std::fs::read_to_string(path)
        .context(format!("Failed to read file at {}", path))?;
    
    let value = parse_data(&data)
        .context("Data format is invalid")?;
    
    // ...
}

fn parse_port(config: &str) -> Result<u16, AppError> {
    config.parse::<u16>()
        .map_err(|e| AppError::Validation {
            field: "port".into(),
            reason: format!("Invalid port number: {}", e),
        })
}

fn main() {
    ifletErr(e) = run_app() {
        eprintln!("Error: {:#}", e);
        ifletSome(source) = e.source() {
            eprintln!("Caused by:");
            for (i, e) in source.chain().enumerate() {
                eprintln!("  {}: {}", i, e);
            }
        }
        process::exit(1);
    }
}

fn connect_with_retry(
    addr: &str,
    retries: usize
) -> Result<Connection> {
    for attempt in0..=retries {
        match connect(addr) {
            Ok(conn) => returnOk(conn),
            Err(e) => {
                if attempt == retries {
                    returnErr(e);
                }
                eprintln!("Attempt {} failed: {}", attempt+1, e);
                thread::sleep(Duration::from_secs(1));
            }
        }
    }
    unreachable!()
}

async fn fetch_data(url: &str) -> Result<String, reqwest::Error> {
    let response = reqwest::get(url)
        .await?
        .error_for_status()?;
    
    response.text().await
}