Capítulo 14: Crates esenciales
rand, regex, serde y clap: el ecosistema trabajando para tu biología
Hasta aquí, todo lo que usamos viene en la biblioteca estándar. Pero una de las grandes alegrías de Rust es su ecosistema de crates (paquetes) en crates.io: miles de librerías listas, con versionado, documentación y tests. Este capítulo instala y usa los cuatro crates que más rendimiento le dan a un biólogo programador: rand para simulación, regex para buscar motivos, serde para guardar resultados en JSON y clap para interfaces de línea de comandos profesionales. Con ellos (y lo aprendido), el proyecto final del próximo capítulo se escribe solo.
14.1 Instalar dependencias
Un crate se agrega a Cargo.toml en la sección [dependencies], o más cómodo, desde la terminal dentro del proyecto:
cargo add randEl resultado en Cargo.toml:
[dependencies]
rand = "0.9"Esa cadena significa “versión 0.9 o cualquier 0.9.x compatible” (versionado semántico: el primer dígito cambia cuando algo se rompe). Cargo descarga, compila y actualiza todo solo: el equivalente a que alguien te arme el laboratorio completo con un comando. Para probar los ejemplos de este capítulo, crea un proyecto cargo new bio_crates y agrega las dependencias que vayamos usando.
14.2 rand: azar con control científico
Toda simulación biológica —mutaciones, deriva, muestreo bootstrap— empieza con números aleatorios. El crate rand es el estándar del tema:
use rand::Rng;
fn main() {
let mut rng = rand::rng(); // generador listo para usar
let base = ['A', 'C', 'G', 'T'];
let elegida = base[rng.random_range(0..4)];
let muta = rng.random_bool(0.001); // ¿muta esta base? p = 0.001
println!("Base sorteada: {}", elegida);
println!("¿Ocurre la mutación?: {}", muta);
}rng() crea el generador, random_range(0..4) sortea en el rango (notación de rangos del capítulo 3) y random_bool(p) lanza una moneda cargada. Simulemos lo que hacemos en pizarra: una secuencia que acumula sustituciones al azar:
use rand::Rng;
fn mutar_secuencia(dna: &str, tasa: f64) -> (String, usize) {
let mut rng = rand::rng();
let bases = ['A', 'C', 'G', 'T'];
let mut mutaciones = 0;
let nueva: String = dna
.chars()
.map(|c| {
if rng.random_bool(tasa) {
mutaciones += 1;
bases[rng.random_range(0..4)]
} else {
c
}
})
.collect();
(nueva, mutaciones)
}
fn main() {
let (hija, n) = mutar_secuencia("ATGGCCTTTTAA", 0.25);
println!("Original: ATGGCCTTTTAA");
println!("Hija: {} ({} sustituciones)", hija, n);
}
// Original: ATGGCCTTTTAA
// Hija: ATGGCTTTTAA (1 sustituciones)La closure del map (capítulo 10) decide base por base si muta — y como map acepta closures que recuerdan (FnMut), puede ir contando las mutaciones en el mismo recorrido. Con tasa = 0.25 sobre 12 bases, lo esperado son 3 mutaciones; tu corrida tendrá otra cifra: la varianza también es biología.
El patrón Monte Carlo —estimar por simulación lo que la teoría predice— cierra el círculo de validación:
use rand::Rng;
fn main() {
let mut rng = rand::rng();
let largo = 1000;
let tasa = 0.001;
let replicas = 10_000;
let mut con_al_menos_una = 0;
for _ in 0..replicas {
let mut toco = false;
for _ in 0..largo {
if rng.random_bool(tasa) {
toco = true;
break;
}
}
if toco {
con_al_menos_una += 1;
}
}
let estimado = con_al_menos_una as f64 / replicas as f64;
let teorico = 1.0 - (1.0 - tasa).powi(largo as i32);
println!("Simulado: {:.3} | Teórico: {:.3}", estimado, teorico);
}
// Simulado: 0.632 | Teórico: 0.632La probabilidad de que un gen de 1000 pb reciba al menos una mutación con tasa 10⁻³ es 1 − (1 − 0.001)¹⁰⁰⁰ ≈ 0.632, y la simulación lo confirma en milisegundos. Cuando simulación y teoría discrepan, una de las dos tiene un bug — y descubrirlo así es mucho mejor que en la revisión de pares.
Los tutoriales viejos usan rand::thread_rng() y gen_range(...): es la API de rand 0.8. En la 0.9 (la actual) se llaman rand::rng() y random_range(...). Si copias código de internet y no compila, revisa la versión en tu Cargo.toml: es la explicación el 90% de las veces.
14.3 regex: buscar motivos sin reinv…
Buscar patrones en secuencias es media bioinformática. Con el crate regex, un motivo se expresa en la notación estándar: . cualquier carácter, [ACGT] una clase, {n,} repeticiones:
use regex::Regex;
fn main() {
let genoma = "TTGAATTCCATGCGAATTCGGCC";
// Sitios de restricción EcoRI: GAATTC
let eco_ri = Regex::new("GAATTC").unwrap();
println!("Sitios EcoRI: {}", eco_ri.find_iter(genoma).count());
}
// Sitios EcoRI: 2Dos cortes para EcoRI (verifícalos: GAATTC aparece en las posiciones 3 y 14 en notación biológica). Y una lección de honestidad experimental: probé el patrón de islas [GC]{4,} sobre esa misma secuencia y el resultado fue vacío — ninguna corrida de 4 o más G/C existe en ella. Con un genoma de prueba más adecuado el patrón sí muestra su valor:
use regex::Regex;
fn main() {
let genoma = "ATGCCCCTAGGGGTTA";
let islas = Regex::new(r"[GC]{4,}").unwrap();
for isla in islas.find_iter(genoma) {
println!("Isla GC: {} ({} pb)", isla.as_str(), isla.len());
}
}
// Isla GC: CCCC (4 pb)
// Isla GC: GGGG (4 pb)Cada isla es un Match con .as_str(), .start(), .end() y .len(). Otras construcciones de uso diario: (?i) ignora mayúsculas ((?i)gaattc encuentra GaAtTc), | alterna (TAA|TAG|TGA son los tres paros) y los grupos (...) capturan para captures(). El motivo del ejercicio final unirá todo: ATG([ACGT]{3}){10,}(TAA|TAG|TGA) es “codón de inicio, diez o más codones cualesquiera, y un paro”: un ORF completo.
14.4 serde: resultados que se guardan solos
serde convierte structs en formatos de archivo y viceversa (el nombre viene de serialization/deserialization). Su súper poder: se deriva, como Debug:
use serde::{Deserialize, Serialize};
#[derive(Serialize, Deserialize, Debug)]
struct Analisis {
id: String,
longitud: usize,
contenido_gc: f64,
}
fn main() -> Result<(), Box<dyn std::error::Error>> {
let a = Analisis {
id: String::from("genA"),
longitud: 12,
contenido_gc: 41.7,
};
let json = serde_json::to_string_pretty(&a)?;
println!("{}", json);
let vuelta: Analisis = serde_json::from_str(&json)?;
println!("Releído: {:?}", vuelta);
Ok(())
}{
"id": "genA",
"longitud": 12,
"contenido_gc": 41.7
}to_string_pretty genera JSON legible; from_str reconstruye el struct completo a partir del texto — incluida la validación de tipos: si el JSON dice "longitud": "doce", serde devuelve error en vez de propagar un string a tus cálculos. Requiere dos dependencias:
[dependencies]
serde = { version = "1", features = ["derive"] }
serde_json = "1"El features = ["derive"] activa la macro #[derive(Serialize)] (las features son interruptores opcionales de un crate). JSON es el formato puerto perfecto: lo lee Python, R (jsonlite), JavaScript y tu cuaderno de laboratorio digital; guardar ahí los parámetros y resultados de cada análisis es la base de la reproducibilidad.
14.5 clap: interfaces de comando profesionales
Nuestras herramientas hasta ahora tenían la configuración escrita en el código. clap (Command Line Argument Parser) convierte un struct en una interfaz de línea de comandos completa, con --help incluido:
use clap::Parser;
/// Analizador básico de secuencias FASTA.
#[derive(Parser)]
#[command(version, about)]
struct Args {
/// Ruta al archivo FASTA de entrada.
fasta: std::path::PathBuf,
/// Umbral mínimo de contenido GC para incluir en el reporte.
#[arg(short, long, default_value_t = 0.0)]
min_gc: f64,
}
fn main() {
let args = Args::parse();
println!("Analizando {} (umbral GC: {:.1}%)",
args.fasta.display(), args.min_gc);
}Compilado y ejecutado con cargo run -- ejemplo.fa --min-gc 40, imprime Analizando ejemplo.fa (umbral GC: 40.0%). La magia está en los detalles de diseño: los doc comments /// se convierten en la ayuda (--help documenta solo), fasta es obligatorio (posicional), --min-gc opcional con default, y -m funciona como abreviatura por el short. Cualquier error de uso produce mensajes como error: the following required arguments were not provided: <FASTA> — cortesía gratis para tus usuarios. La dependencia: cargo add clap --features derive.
14.6 El mapa del ecosistema biológico
| Crate | Para qué | Mención de honor |
|---|---|---|
bio |
alineamientos, alfabetos, manipulación de intervalos | el “Biopython de Rust” |
needletail |
lectura ultrarrápida de FASTA/FASTQ | streaming, genomas enteros |
rand |
simulación estocástica | mutaciones, muestreo |
regex |
motivos y patrones | sitios de restricción, ORFs |
serde + serde_json |
JSON entrante y saliente | config y resultados |
clap |
interfaces de comando | tu herramienta parece oficial |
rayon |
paralelismo por datos | par_iter() en vez de iter() |
polars |
dataframes rápidos | el hermano turbo de pandas |
anyhow / thiserror |
errores ergonómicos | menos ceremonia que Box<dyn Error> |
La estrategia de aprendizaje no es memorizar la tabla, sino un patrón: cada vez que escribas 20 líneas para algo que “seguro alguien ya necesitó”, busca el crate. Y antes de confiar, mira sus tests, su documentación y su actividad de mantenimiento — mismo criterio que usas con un protocolo de laboratorio nuevo.
Ejercicios
Ejercicio 14.1 · Tres enzimas de restricción
Con regex, cuenta los sitios de corte de EcoRI (GAATTC), BamHI (GGATCC) y HindIII (AAGCTT) en TTGAATTCCGGATCCAAGCTTGAATTC, e imprime el total de cortes posibles.
Solución
use regex::Regex;
fn main() {
let genoma = "TTGAATTCCGGATCCAAGCTTGAATTC";
let enzimas = [
("EcoRI", "GAATTC"),
("BamHI", "GGATCC"),
("HindIII", "AAGCTT"),
];
let mut total = 0;
for (nombre, sitio) in enzimas {
let patron = Regex::new(sitio).unwrap();
let n = patron.find_iter(genoma).count();
println!("{} ({}): {} sitios", nombre, sitio, n);
total += n;
}
println!("Total de cortes posibles: {}", total);
}
// EcoRI (GAATTC): 2 sitios
// BamHI (GGATCC): 1 sitios
// HindIII (AAGCTT): 1 sitios
// Total de cortes posibles: 4Verifica: GAATTC aparece al inicio (TT|GAATTC|CC...) y hacia el final (...AAGCTT|GAATTC) ✓; GGATCC una vez en el medio ✓; AAGCTT una vez ✓. Este programa, con un for sobre archivos, es un mapa de restricción digital en 15 líneas.
Ejercicio 14.2 · Deriva del contenido GC
Simula 50 generaciones de una secuencia de 100 pb inicial de puro G y C ("GC".repeat(50)), aplicando en cada generación mutar_secuencia con tasa 0.01, y registra el contenido GC cada 10 generaciones.
Solución
use rand::Rng;
fn mutar_secuencia(dna: &str, tasa: f64) -> String {
let mut rng = rand::rng();
let bases = ['A', 'C', 'G', 'T'];
dna.chars()
.map(|c| if rng.random_bool(tasa) { bases[rng.random_range(0..4)] } else { c })
.collect()
}
fn contenido_gc(dna: &str) -> f64 {
let gc = dna.bytes().filter(|b| *b == b'G' || *b == b'C').count();
gc as f64 / dna.len() as f64 * 100.0
}
fn main() {
let mut secuencia = "GC".repeat(50);
println!("Generación 0: {:.1}% GC", contenido_gc(&secuencia));
for generacion in 1..=50 {
secuencia = mutar_secuencia(&secuencia, 0.01);
if generacion % 10 == 0 {
println!("Generación {}: {:.1}% GC", generacion, contenido_gc(&secuencia));
}
}
}
// Generación 0: 100.0% GC
// Generación 10: 95.0% GC
// Generación 20: 92.0% GC
// Generación 30: 92.0% GC
// Generación 40: 90.0% GC
// Generación 50: 89.0% GC(Tus números variarán: son simulaciones, y esa es la gracia.) La deriva hacia el equilibrio 50% es la predicción de la teoría neutralista: sin selección, el azar erosiona cualquier composición inicial. Un ejercicio de extensión natural: correr 1000 réplicas y graficar la distribución final del GC — con serde guardando los resultados y R graficándolos.
Ejercicio 14.3 · Configuración en JSON
Define ParametrosSimulacion { largo: usize, tasa: f64, generaciones: u32 } con derives Serialize/Deserialize, escríbelo como config.json con valores 100, 0.01 y 50, y luego léelo de vuelta e imprímelo con {:?}.
Solución
use serde::{Deserialize, Serialize};
use std::fs;
#[derive(Serialize, Deserialize, Debug)]
struct ParametrosSimulacion {
largo: usize,
tasa: f64,
generaciones: u32,
}
fn main() -> Result<(), Box<dyn std::error::Error>> {
let params = ParametrosSimulacion { largo: 100, tasa: 0.01, generaciones: 50 };
let json = serde_json::to_string_pretty(¶ms)?;
fs::write("config.json", &json)?;
let leidos: ParametrosSimulacion = serde_json::from_str(&fs::read_to_string("config.json")?)?;
println!("Leídos: {:?}", leidos);
Ok(())
}
// Leídos: ParametrosSimulacion { largo: 100, tasa: 0.01, generaciones: 50 }El archivo config.json queda en disco, versionable en git y editable a mano: cambia tasa a 0.05 en el JSON y relanza la simulación sin recompilar nada. Este ciclo —config en JSON, resultados en JSON— es el estándar de reproducibilidad del proyecto final.
Ejercicio 14.4 · ORFs con regex
Usa el patrón ATG([ACGT]{3}){10,}(TAA|TAG|TGA) para encontrar ORFs completos (inicio + al menos 10 codones + paro) en la secuencia ATGGCTGCTGCTGCTGCTGCTGCTGCTGCTTAAGATGTTTTAA, reportando cuántos hay y la longitud de cada uno.
Solución
use regex::Regex;
fn main() {
let secuencia = "ATGGCTGCTGCTGCTGCTGCTGCTGCTGCTTAAGATGTTTTAA";
let patron = Regex::new(r"ATG([ACGT]{3}){10,}(TAA|TAG|TGA)").unwrap();
for orf in patron.find_iter(secuencia) {
println!("ORF de {} pb: {}", orf.len(), orf.as_str());
}
}
// ORF de 39 pb: ATGGCTGCTGCTGCTGCTGCTGCTGCTGCTTAAAnatomía de la coincidencia: ATG (inicio) + diez GCT (codones intermedios: 30 pb) + TAA (paro) = 39 pb. El segundo ATG de la secuencia seguido de un solo codón TTT y el paro TAA no cumple el mínimo de 10 codones, así que queda fuera — el patrón codificó el criterio biológico completo. Con captures() podrías además extraer qué codón de paro usó cada ORF: hazlo cuando lo necesites en el proyecto final.
Ejercicio 14.5 · Tu herramienta con clap
Convierte el pipeline FASTA → TSV del capítulo 12 en una herramienta CLI: bio-stats <FASTA> [--min-gc 0] [--salida reporte.tsv], donde --min-gc filtra registros y --salida cambia el archivo destino.
Solución
use clap::Parser;
use std::fs;
use std::io::Write;
use std::path::PathBuf;
#[derive(Parser)]
#[command(version, about = "Estadísticas de un archivo FASTA")]
struct Args {
/// Ruta al archivo FASTA de entrada.
fasta: PathBuf,
/// Contenido GC mínimo (%) para incluir el registro.
#[arg(long, default_value_t = 0.0)]
min_gc: f64,
/// Archivo de salida para el reporte TSV.
#[arg(short, long, default_value = "reporte.tsv")]
salida: PathBuf,
}
fn contenido_gc(dna: &str) -> f64 {
let gc = dna.bytes().filter(|b| *b == b'G' || *b == b'C').count();
gc as f64 / dna.len() as f64 * 100.0
}
fn parsear_fasta(texto: &str) -> Vec<(String, String)> {
let mut registros = Vec::new();
let (mut id, mut bases) = (String::new(), String::new());
for linea in texto.lines() {
let linea = linea.trim();
if linea.is_empty() { continue; }
if let Some(encabezado) = linea.strip_prefix('>') {
if !id.is_empty() { registros.push((id, bases)); }
id = encabezado.split_whitespace().next().unwrap_or("").to_string();
bases = String::new();
} else {
bases.push_str(&linea.to_uppercase());
}
}
if !id.is_empty() { registros.push((id, bases)); }
registros
}
fn main() -> Result<(), Box<dyn std::error::Error>> {
let args = Args::parse();
let registros = parsear_fasta(&fs::read_to_string(&args.fasta)?);
let mut salida = fs::File::create(&args.salida)?;
writeln!(salida, "id\tlongitud\tpct_gc")?;
let mut incluidos = 0;
for (id, bases) in ®istros {
let gc = contenido_gc(bases);
if gc >= args.min_gc {
writeln!(salida, "{}\t{}\t{:.1}", id, bases.len(), gc)?;
incluidos += 1;
}
}
println!("{} de {} registros -> {}",
incluidos, registros.len(), args.salida.display());
Ok(())
}Probado con cargo run -- ejemplo.fa --min-gc 50 --salida altos.tsv, el programa deja en altos.tsv solo las secuencias GC-ricas. En 50 líneas tienes una herramienta con documentación automática, validación de argumentos y flags documentados: la distancia entre “script del curso” y “software que un colega puede usar” era solo un clap. Mañana la cruzamos con módulos, tests y reportes JSON: es el proyecto final.
