Trabajo con YAML en Rust: biblioteca serde_yaml

Introducción al trabajo con YAML en Rust

YAML (YAML Ain't Markup Language) es uno de los formatos más populares para archivos de configuración gracias a su legibilidad y flexibilidad. En el ecosistema de Rust, para trabajar con YAML se utiliza el crate serde_yaml, que está construido sobre la potente plataforma de serialización Serde. Esta biblioteca permite transformar fácilmente estructuras de Rust a YAML y viceversa.

Instalación y configuración

Agregue las dependencias a su Cargo.toml:

[dependencies]serde = { version = "1.0", features = ["derive"] }serde_yaml = "0.9"

Después de actualizar el proyecto, ejecute cargo build. La biblioteca está lista para usar.

Deserialización básica de YAML en Rust

Veamos un ejemplo simple: leer una cadena YAML y convertirla en una estructura de Rust.

Paso 1: Definir la estructura

use serde::Deserialize;

#[derive(Debug, Deserialize)]struct Config {    host: String,    port: u16,    debug: bool,}

Paso 2: Analizar el YAML

use serde_yaml;

fn main() -> Result<(), serde_yaml::Error> {    let yaml_str = r#"        host: "127.0.0.1"        port: 8080        debug: true    "#;

    let config: Config = serde_yaml::from_str(yaml_str)?;    println!("{:?}", config);    Ok(())}

Salida: Config { host: "127.0.0.1", port: 8080, debug: true }

Serialización de estructuras de Rust a YAML

El proceso inverso: convertir datos de Rust a una cadena YAML:

use serde::Serialize;

#[derive(Debug, Serialize)]struct Server {    name: String,    ip: String,    ports: Vec<u16>,}

fn main() -> Result<(), serde_yaml::Error> {    let server = Server {        name: "web-server".into(),        ip: "10.0.0.1".into(),        ports: vec![80, 443, 22],    };

    let yaml = serde_yaml::to_string(&server)?;    println!("{}", yaml);    Ok(())}

Resultado:

---name: web-serverip: 10.0.0.1ports:  - 80  - 443  - 22

Trabajo con estructuras anidadas y etiquetas

YAML admite jerarquías complejas. En Rust, esto se refleja en estructuras y enumeraciones anidadas:

use serde::{Deserialize, Serialize};

#[derive(Debug, Serialize, Deserialize)]struct Database {    #[serde(rename = "db")]    database: DbConfig,    pool_size: u32,}

#[derive(Debug, Serialize, Deserialize)]struct DbConfig {    host: String,    port: u16,    user: String,    password: String,}

fn main() -> Result<(), serde_yaml::Error> {    let yaml = r#"        db:          host: "localhost"          port: 5432          user: "admin"          password: "secret"        pool_size: 10    "#;

    let db: Database = serde_yaml::from_str(yaml)?;    println!("{:#?}", db);    Ok(())}

Observe el atributo #[serde(rename = "db")] — permite asociar un campo de Rust con otro nombre en YAML.

Manejo de errores y campos opcionales

Los archivos YAML reales a menudo contienen parámetros opcionales. Use Option<T>:

#[derive(Debug, Deserialize)]struct AppConfig {    name: String,    version: String,    #[serde(default)]    features: Vec<String>,    #[serde(default = "default_timeout")]    timeout: u64,}

fn default_timeout() -> u64 {    30}

El atributo #[serde(default)] asigna un valor por defecto (vector vacío para Vec, None para Option). Se puede especificar una función generadora, como en el ejemplo con timeout.

Lectura de YAML desde un archivo

En la práctica, las configuraciones se almacenan en archivos. La lectura es simple:

use std::fs;use serde_yaml;

fn main() -> Result<(), Box<dyn std::error::Error>