Cache em Rust: biblioteca cached

O que é `cached` e para que serve?

A biblioteca cached é uma ferramenta poderosa e flexível para armazenar em cache os resultados de chamadas de funções em Rust. Ela permite acelerar significativamente a execução de programas, evitando recálculos de operações custosas (por exemplo, consultas a bancos de dados, cálculos com grandes volumes de dados, chamadas a APIs externas). O cache é especialmente útil em servidores web, motores de jogos, sistemas analíticos e qualquer aplicação onde os mesmos dados são solicitados repetidamente.

Instalação

Adicione a dependência ao seu Cargo.toml:

[dependencies]cached = "0.48"

Depois disso, execute cargo build — a biblioteca está pronta para uso.

Funcionalidades principais

Cache de funções — salvamento automático dos resultados da chamada de uma função com base nos seus argumentos.
TTL (Time To Live) — define o tempo de vida do cache, após o qual os dados são automaticamente removidos.
Tamanho máximo do cache — limitação da quantidade de entradas armazenadas (heurística LRU).
Suporte assíncrono — trabalho com funções async através de cached::async.
Armazenamentos — suporte integrado para Redis, Memcached, cache de arquivos e armazenamento in-memory.

Exemplo de código em Rust

use cached::proc_macro::cached;use std::time::Duration;

// Armazenamos em cache a função com TTL de 60 segundos e máximo de 10 entradas#[cached(    time = 60,    size = 10,    key = "u32",    convert = r#"{ _input }"#)]fn expensive_computation(input: u32) -> String {    println!("Calculando para {}", input);    std::thread::sleep(Duration::from_secs(2));    format!("Resultado para {}", input)}

fn main() {    // Primeira chamada — cálculo (2 segundos)    println!("{}", expensive_computation(42));    // Segunda chamada — retorno instantâneo do cache    println!("{}", expensive_computation(42));}

Na primeira chamada de expensive_computation(42), a função será executada (atraso de 2 segundos), e na chamada repetida, o resultado será obtido instantaneamente do cache.

Quando usar

A biblioteca cached é ideal para:

Acelerar funções chamadas com frequência com argumentos inalterados.
Reduzir a carga em bancos de dados ou serviços externos.
Implementar memoização em algoritmos recursivos (por exemplo, números de Fibonacci).
Criar camadas de proxy de cache em APIs.

Evite o cache se os dados mudam com frequência ou se o resultado depende de estado externo (hora, aleatoriedade).

Conclusão

cached é uma biblioteca minimalista, mas poderosa, que resolve 90% das tarefas de cache em Rust. Graças às macros, ela não requer código boilerplate e se integra facilmente em qualquer projeto. Instale-a hoje mesmo e sinta o ganho de desempenho!