Rust como cola universal: Integração com Python, C e outras linguagens

Rust como cola universal: por que a integração com outras linguagens é uma superpotência

Você já sonhou em escrever um módulo de alto desempenho em Rust, mas não queria reescrever todo o projeto em Python? Ou talvez precise adicionar gerenciamento seguro de memória a uma biblioteca C antiga? Bem-vindo ao mundo da integração do Rust com outras linguagens. Aqui, o Rust atua não apenas como uma linguagem independente, mas como uma poderosa "cola" que conecta ecossistemas.

No pythonlib.ru, falamos frequentemente sobre Python, mas hoje daremos uma guinada interessante. Rust não é apenas velocidade e segurança, mas também uma flexibilidade incrível. Ele consegue integrar-se com Python através do PyO3, chamar funções C via FFI e até mesmo compilar para WebAssembly para o navegador. Neste artigo, vamos explorar três cenários principais, mostrar código real e dar dicas práticas. Vamos lá!

Por que integrar Rust com outras linguagens?

Imagine: você tem um enorme projeto em Python que está lento devido a loops. Você pode reescrever a parte crítica em Rust, obter um ganho de velocidade de 10 a 100 vezes e não mexer no resto do código. Ou você trabalha com uma biblioteca C legada e quer envolvê-la em uma interface Rust segura. Rust é ideal para isso graças à Foreign Function Interface (FFI).

Principais razões para a integração:

\n
• Desempenho — Rust é mais rápido que Python e JavaScript em tarefas computacionais.
\n
• Segurança — Rust protege contra vazamentos de memória e condições de corrida, o que é crítico para C/C++.
\n
• Ecossistema — você obtém acesso às bibliotecas Rust sem sair da sua linguagem nativa.
\n
• WebAssembly — o código Rust roda no navegador com velocidade quase nativa.
\n

Integração Rust com Python via PyO3

PyO3 é a maneira mais popular de conectar Rust e Python. Você escreve funções em Rust, as compila em um módulo nativo (.so ou .pyd) e as importa como um módulo Python comum. Parece mágica? Na prática, é simples.

Instalação e configuração

Para começar, instale o maturin — a ferramenta para compilar extensões Rust para Python:

pip install maturin

Crie um novo projeto:

maturin init --bindings pyo3

Isso criará uma estrutura com os arquivos Cargo.toml e lib.rs.

Exemplo: acelerando cálculos

Suponha que precisamos calcular rapidamente números de Fibonacci. Em Python pode ser lento, mas em Rust é instantâneo. Aqui está o código em src/lib.rs:

use pyo3::prelude::*;\n\n#[pyfunction]\nfn fibonacci(n: u32) -> u64 {\n    match n {\n        0 => 0,\n        1 => 1,\n        _ => fibonacci(n - 1) + fibonacci(n - 2),\n    }\n}\n\n#[pymodule]\nfn rust_fib(_py: Python, m: &PyModule) -> PyResult<()> {\n    m.add_function(wrap_pyfunction!(fibonacci, m)?)?;\n    Ok(())\n}

Compilamos o módulo:

maturin develop

Agora em Python:

import rust_fib\nprint(rust_fib.fibonacci(40))  # 102334155

Compare a velocidade com o Python puro — a diferença será de dezenas de vezes! Este é um exemplo perfeito de integração Rust com Python para otimização.

Transferência de dados complexos

PyO3 suporta não apenas números, mas também listas, dicionários e até arrays numpy. Por exemplo, podemos passar uma lista e processá-la em Rust:

#[pyfunction]\nfn sum_list(numbers: Vec<i32>) -> i32 {\n    numbers.iter().sum()\n}

Em Python:

print(rust_fib.sum_list([1, 2, 3, 4]))  # 10

Isso abre enormes possibilidades para integração Rust com Python em ciência de dados e desenvolvimento web.

Rust e C: FFI clássico

Rust foi criado como um substituto para C/C++, portanto, FFI Rust é sua especialidade nativa.