A linguagem Alpaca combina o sistema de tipos estáticos e a elegância da programação funcional inspirada em ML com a robustez da máquina virtual BEAM. Projetada para a construção de sistemas concorrentes seguros, ela introduz tipos algébricos de dados (ADT) e correspondência de padrões no ecossistema Erlang, garantindo segurança em tempo de compilação.

Estrutura de Módulos e Ambiente de Desenvolvimento

Programas em Alpaca são organizados em módulos, cada um contendo declarações de exportação, definições de tipos e funções. A estrutura de projeto segue as convenções do Erlang/OTP, com código-fonte no diretório src e testes no test.

module calculadora
export multiplicar/2
type numero = Int int | Float float
let multiplicar a b = a * b

O ambiente de desenvolvimento requer Erlang/OTP 19.3 ou superior e o construtor Rebar3. A configuração do Rebar3 inclui um plugin para compilar código Alpaca integrado ao fluxo de build do Erlang.

Sistema de Tipos: Fundamentos e Composições

Alpaca oferece tipos básicos como booleanos, inteiros, floats, átomos e strings, com operações estritamente tipadas. Tipos compostos incluem tuplas, listas, mapas e registros, cada um com semântica definida para correspondência de padrões.

-- Tupla heterogênea
let dados = (42, "texto", :ok)
let extrair_segundo (_, y, _) = y

-- Lista homogênea com recursão
let rec somar_lista lst =
  match lst with
    [] -> 0
  | h :: t -> h + somar_lista t

Registros suportam polimorfismo de linha, permitindo a atualização não destrutiva de campos mantendo a tipagem de outros campos.

let ponto = {x=1, y=2.0}
let ponto_novo = {x=5 | ponto}  -- Tipagem: {x: int, y: float}

Programação Funcional: Funções e Tipos Algébricos

Funções em Alpaca são curried por padrão, facilitando a aplicação parcial. Tipos algébricos de dados (ADT) modelam dados complexos com construtores paramétricos e tipos recursivos.

type forma = Circulo float | Retangulo float float
let calcular_area f =
  match f with
    Circulo r -> 3.14 *. r *. r
  | Retangulo l a -> l *. a

-- Polimorfismo com ADT
type resultado 'a = Sucesso 'a | Erro string
let processar res =
  match res with
    Sucesso val -> val
  | Erro msg -> falhar msg

A inferência de tipos segue o algoritmo Hindley-Milner, eliminando a necessidade de anotações explícitas na maioria dos casos.

Programação Concorrente: Processos e Mensagens Tipadas

Alpaca utiliza o modelo de concorrência baseado em atores do Erlang, com verificação de tipos em tempo de compilação para mensagens trocadas entre processos.

-- Processo contador com protocolo de mensagens
type comando = Incrementar | Decrementar | Obter (pid int)
let rec contador valor =
  receive with
    Incrementar -> contador (valor + 1)
  | Decrementar -> contador (valor - 1)
  | Obter remetente ->
      send valor remetente
      contador valor

-- Inicialização e comunicação segura
let pid_contador = spawn contador 0
send Incrementar pid_contador

Erros de tipagem em mensagens, como enviar uma string para um processo que espera átomos, são detectados durante a compilação.

Integração com o Ecossistema Erlang

Alpaca permite chamar funções Erlang diretamente via interface FFI, mentendo a segurença de tipos através de correspondência de padrões nos retornos.

let listar_diretorio caminho =
  beam :filelib :wildcard [caminho ++ "/*"] with
    arquivos, is_list arquivos -> arquivos

O processo de build utiliza Rebar3 com hooks para compilação automática de arquivos .alp. Testes são definidos inline usando a palavra-chave test e executados com EUnit.

Caso Prático: Serviço de Chat Tipado

Um sistema de chat simples demonstra a aplicação de ADT para protocolos de mensagens e processos para gestão de estado.

type mensagem_chat =
    Entrar string (pid mensagem_chat)
  | Enviar string string
  | Sair string
type estado_sala = {usuarios: list (string, pid mensagem_chat), historico: list string}

O processo da sala mantém o estado e difunde mensagens, enquanto clientes interagem via loops de recebimento e envio. A tipagem estática assegura que apenas mensagens válidas sejam trocadas entre componentes.

Estado Atual e Evolução

Alpaca está em desenvolvimento ativo, com limitações na biblioteca padrão e suporte a exceções. Melhorias planejadas incluem o sistema de módulos e otimizações de desempenho. A linguagem é aedquada para sistemas de alta confiabilidade, aplicações concorrentes e modernização de bases Erlang.