DSL en Rust: escribe tu propio lenguaje para problemas reales

¿Por qué un desarrollador de Rust necesitaría su propio lenguaje? Inmersión en el mundo de los DSL

Imagina que estás escribiendo un analizador sintáctico para un archivo de configuración complejo, implementando lógica de juego o describiendo reglas de negocio. Cada vez te encuentras con lo mismo: el código se vuelve voluminoso y la legibilidad disminuye. ¿Qué pasaría si pudieras crear un mini-lenguaje, especialmente diseñado para tu tarea? Eso es un lenguaje específico del dominio (DSL en Rust).

Rust es el entorno ideal para crear DSL. Su sistema de macros, potente inferencia de tipos y abstracciones de costo cero permiten construir lenguajes que no tienen nada que envidiar en rendimiento al código escrito a mano. En este artículo, analizaremos cómo convertir Rust en un constructor de tus propios lenguajes y mostraremos por qué esto puede ser útil precisamente para ti.

¿Qué es un DSL y para qué sirve en Rust?

Un DSL (Domain-Specific Language) es un lenguaje creado para resolver problemas en un área de conocimiento específica. A diferencia de un lenguaje de programación de propósito general, un DSL sacrifica la universalidad en favor de la expresividad en un nicho concreto. En el ecosistema de Rust existen dos enfoques principales:

• DSL internos (embebidos) — se construyen sobre la sintaxis de Rust utilizando macros y cadenas de métodos. Ejemplo: la biblioteca clap para analizar argumentos de línea de comandos.
• DSL externos — una sintaxis separada que se analiza en tiempo de ejecución. Ejemplo: regex o sqlx.

El desarrollo de DSL en Rust es especialmente relevante para:

• Archivos de configuración (YAML/TOML como DSL externos)
• Motores de juegos (descripción del comportamiento de NPC)
• Frameworks de pruebas (sintaxis propia para escenarios)
• Equilibrio entre seguridad y flexibilidad

Creando un DSL interno en Rust: macros y cadenas

Empecemos con algo simple: un DSL interno para describir solicitudes HTTP. En lugar de escribir:

let mut req = Request::new(Method::GET);req.set_url("https://api.example.com/data");req.add_header("Authorization", "Bearer token");req.add_header("Content-Type", "application/json");

Queremos obtener una sintaxis concisa:

let req = request! {    GET "https://api.example.com/data"    headers {        "Authorization": "Bearer token",        "Content-Type": "application/json"    }};

Lo implementamos usando macros de Rust, la herramienta más potente para crear DSL internos:

macro_rules! request {    ($method:ident $url:expr) => {        Request::new(stringify!($method).parse().unwrap(), $url)    };    ($method:ident $url:expr, headers { $($key:expr => $value:expr),* $(,)? }) => {        {            let mut req = Request::new(stringify!($method).parse().unwrap(), $url);            $(                req.add_header($key, $value);            )*            req        }    };}

Este enfoque es un ejemplo clásico de lenguaje específico del dominio en Rust: no creamos una sintaxis nueva, sino que redefinimos la existente, haciendo el código más legible. Observa: la macro genera código Rust normal en tiempo de compilación, por lo que los errores de tipo se detectan antes de la ejecución.

DSL interno avanzado: patrón Constructor (Builder pattern)

Las macros no son la única forma. A menudo, para crear DSL en Rust se utiliza el patrón Builder con cadenas de métodos. Consideremos un ejemplo de DSL para consultas SQL:

let query = Query::select()    .from("users")    .where_clause("age > ?")    .bind(18)    .order_by("name")    .build();

La implementación de dicho DSL es simple y elegante:

struct QueryBuilder {    select: Vec<String>,    from: String,    condition: Option<String>,    order: Option<String>,}\