Gleam: a linguagem funcional com tipos que roda na BEAM e em JavaScript

1. O que é Gleam e por que ela surge agora?

Gleam é uma linguagem de programação funcional com sistema de tipos estáticos e fortes, criada por Louis Pilfold em 2019. Ela ocupa um espaço único no ecossistema de linguagens: compila tanto para a BEAM (máquina virtual do Erlang) quanto para JavaScript. Isso significa que um mesmo código pode rodar em servidores Elixir/Erlang, no navegador ou no Node.js.

Historicamente, desenvolvedores que apreciavam a concorrência e tolerância a falhas da BEAM precisavam escolher entre Elixir (dinâmico) ou Erlang (estático, mas com sintaxe datada). Gleam surge para preencher essa lacuna: oferece type safety moderno com inferência de tipos, sem abrir mão dos superpoderes da BEAM.

A filosofia de design é clara: simplicidade funcional com segurança de tipos. Não há herança, nulabilidade ou efeitos colaterais implícitos. Tudo é imutável por padrão, e o compilador captura erros antes da execução.

2. Primeiros passos: sintaxe que parece familiar (mas não é)

A sintaxe de Gleam é inspirada em Rust e Elm, mas com influências de Elixir. Veja um exemplo básico:

pub fn saudacao(nome: String) -> String {
  "Olá, " <> nome <> "!"
}

pub fn main() {
  let nome = "Mundo"
  io.println(saudacao(nome))
}

Pattern matching é onipresente:

pub type Resultado {
  Sucesso(Int)
  Erro(String)
}

pub fn processar(valor: Int) -> Resultado {
  case valor {
    0 -> Erro("Valor não pode ser zero")
    n if n < 0 -> Erro("Valor negativo")
    n -> Sucesso(n * 2)
  }
}

Não existem loops for ou while. A recursão é a principal ferramenta de iteração:

pub fn fatorial(n: Int) -> Int {
  case n {
    0 -> 1
    n -> n * fatorial(n - 1)
  }
}

List comprehensions oferecem uma alternativa concisa:

pub fn dobrar_pares(lista: List(Int)) -> List(Int) {
  list.map(lista, fn(x) { x * 2 })
}

3. O sistema de tipos que não atrapalha (e ajuda)

O sistema de tipos de Gleam é um dos seus maiores atrativos. Ele usa inferência robusta: você raramente precisa anotar tipos explicitamente, mas o compilador conhece todos eles.

Os tipos Result(a, b) e Option(a) substituem exceções e valores nulos:

pub fn dividir(a: Int, b: Int) -> Result(Int, String) {
  case b {
    0 -> Error("Divisão por zero")
    _ -> Ok(a / b)
  }
}

pub fn usar_divisao() {
  let resultado = dividir(10, 2)
  case resultado {
    Ok(valor) -> io.println("Resultado: " <> int.to_string(valor))
    Error(msg) -> io.println("Erro: " <> msg)
  }
}

Isso elimina bugs comuns de JavaScript (como undefined is not a function) e de Erlang (badarg errors em tempo de execução). O compilador de Gleam é rigoroso: se compila, provavelmente está correto.

4. Rodando na BEAM: concorrência com superpoderes

A BEAM é famosa por seu modelo de concorrência baseado em atores (processos leves). Gleam herda tudo isso:

pub fn worker(id: Int) {
  process.sleep(1000)
  io.println("Processo " <> int.to_string(id) <> " finalizado")
}

pub fn main() {
  let pid1 = process.spawn(fn() { worker(1) })
  let pid2 = process.spawn(fn() { worker(2) })

  // Enviar mensagem para um processo
  process.send(pid1, "mensagem")

  process.sleep(2000)
}

Tolerância a falhas é nativa. Com let assert e o ecossistema OTP, você cria sistemas que se recuperam automaticamente:

pub fn servidor_supervisor() {
  let assert Ok(_) = supervisor.start_link(...)
  // Se um processo filho falhar, o supervisor reinicia
}

A BEAM brilha em aplicações de telecomunicações, IoT, sistemas de tempo real e qualquer cenário que exija alta disponibilidade e concorrência massiva.

5. Compilando para JavaScript: o melhor dos dois mundos

O target JavaScript permite que Gleam rode em navegadores e Node.js:

// Compile com: gleam compile --target javascript
pub fn somar(a: Int, b: Int) -> Int {
  a + b
}

Interoperabilidade é direta. Você pode chamar funções JavaScript de Gleam:

@external(javascript, "./meu_modulo.js", "funcao_js")
pub fn chamar_js() -> String

E vice-versa: o código compilado gera módulos ES6 que podem ser importados em projetos npm.

Para frontend, o framework Lustre permite criar aplicações web reativas no estilo Elm:

pub fn view(model: Model) -> Element(Msg) {
  html.div([], [
    html.h1([], [html.text("Olá, Gleam!")]),
    html.button([events.on_click(Clicked)], [html.text("Clique")])
  ])
}

6. Gleam no ecossistema real: ferramentas e bibliotecas

O gerenciamento de pacotes usa o Hex (mesmo repositório de Elixir e Erlang):

gleam add wisp mist lustre

Testes e documentação são integrados:

gleam test    # Executa testes
gleam docs    # Gera documentação HTML

Projetos notáveis incluem:
- Wisp: servidor HTTP minimalista
- Mist: servidor HTTP de alto desempenho
- Lustre: framework frontend reativo
- Gleam Graphics: biblioteca para jogos 2D
- Gleam SQLite: bindings para SQLite

7. Comparações práticas: Gleam vs. Elixir, TypeScript e Rust

Gleam vs. Elixir: Elixir oferece metaprogramação poderosa (macros) e um ecossistema maduro (Phoenix, Nx). Gleam sacrifica isso por type safety. Para projetos onde tipos estáticos são prioridade, Gleam vence.

Gleam vs. TypeScript: TypeScript tem um sistema de tipos complexo e configurável. Gleam é mais simples e previsível. TypeScript tem ecossistema maior; Gleam oferece concorrência real e tolerância a falhas.

Gleam vs. Rust: Rust oferece controle de memória e performance máxima. Gleam (via BEAM) oferece concorrência leve e tolerância a falhas. Para sistemas críticos de baixo nível, Rust; para sistemas distribuídos e de alta disponibilidade, Gleam.

8. Vale a pena aprender Gleam em 2025?

A curva de aprendizado é suave para quem vem de JavaScript (sintaxe familiar), Elixir (conceitos de concorrência) ou Python (simplicidade). O mercado ainda é nicho, mas crescente: startups de sistemas distribuídos, empresas de telecomunicações e projetos de IoT estão adotando Gleam.

Indicado para:
- Desenvolvedores que querem type safety sem complexidade
- Quem precisa de concorrência massiva e tolerância a falhas
- Projetos que rodam tanto no backend (BEAM) quanto no frontend (JS)

Evitar quando:
- O ecossistema da biblioteca for insuficiente
- Performance bruta de CPU for crítica (prefira Rust ou C++)
- Metaprogramação extensiva for necessária (prefira Elixir)

Gleam é uma linguagem que resolve problemas reais com elegância. Em 2025, aprender Gleam é investir em um futuro onde sistemas distribuídos seguros e performáticos são a norma.

Referências