Programação · Conceitos · Compilador

O que é um compilador?

Você escreve um programa numa linguagem que sabe ler: palavras, indentação, nomes com significado. O processador da sua máquina não entende nada disso — ele executa instruções binárias cruas. A ferramenta que faz a ponte é o compilador. Este guia explica o que é um compilador, as etapas pelas quais ele passa, em que difere de um interpretador, e onde um compilador como o GHC se encaixa quando você escreve Haskell.

A definição curta

Um compilador é um programa que traduz código-fonte escrito numa linguagem para outra forma — normalmente o código de máquina que um computador pode executar diretamente. Você entrega os arquivos de texto que escreveu e ele produz um executável (ou um formato intermediário) que a máquina, ou um runtime, pode executar. A tradução acontece uma vez, antecipadamente, e o resultado roda sozinho, sem que o compilador esteja presente.

Como um compilador funciona, etapa por etapa

Um compilador não traduz num único salto. Ele percorre uma cadeia de etapas, cada uma passando o seu resultado para a seguinte:

• Análise léxica (tokenização): o texto-fonte é dividido em pequenas unidades — palavras-chave, nomes, números, símbolos — chamadas tokens.
• Análise sintática (parsing): os tokens são organizados numa árvore que reflete a estrutura do programa, segundo a gramática da linguagem.
• Análise semântica: o compilador verifica se o programa faz sentido — nomes definidos, tipos coerentes, regras da linguagem respeitadas. É aqui que muitos dos seus erros são detectados.
• Otimização: o compilador reescreve o programa num equivalente mais rápido ou menor sem mudar o que ele faz.
• Geração de código: por fim ele emite a saída-alvo — código de máquina, ou uma representação intermediária que outra ferramenta vai finalizar.

Se alguma etapa encontrar um problema, você recebe um erro de compilação e nenhum programa é produzido. É o trato do compilador: ele se recusa a construir código quebrado, então toda uma classe de erros é capturada antes mesmo de o programa rodar.

Compilador vs interpretador

A outra abordagem comum é o interpretador, que lê o seu código-fonte e o executa diretamente, linha por linha, cada vez que o programa roda — nenhum executável separado é construído antecipadamente. Um compilador traduz o programa inteiro uma vez, no início, para uma forma que a máquina executa sozinha.

A diferença prática: programas compilados costumam iniciar e rodar mais rápido, porque a tradução e a otimização já aconteceram, e os erros aparecem em tempo de compilação. Programas interpretados são mais rápidos de testar e mais flexíveis, mas refazem o trabalho de tradução a cada execução. Muitas toolchains reais misturam as duas — compilam para uma forma intermediária e depois a executam numa máquina virtual.

Onde GHC e Haskell se encaixam

Quando você escreve Haskell, o compilador que usa é o GHC (o Glasgow Haskell Compiler). Ele lê os seus arquivos-fonte .hs, verifica os tipos a fundo, otimiza o resultado e produz um executável nativo que você pode rodar sozinho. O forte sistema de tipos do Haskell faz com que a etapa de análise semântica do GHC trabalhe muito por você: muitos bugs são reportados como erros de compilação em vez de quebrarem em tempo de execução. Para o passo a passo completo do uso, veja o nosso guia do compilador GHC e como instalar o Haskell com o GHCup.

Os comandos que você realmente encontra

• Compilar um único arquivo: uma ferramenta como ghc Main.hs lê o seu fonte e produz um executável.
• Construir um projeto: ferramentas de build como Cabal ou Stack conduzem o compilador através de muitos arquivos e dependências por você.
• Verificar tipos sem um build completo: muitos compiladores oferecem um modo mais rápido que procura erros sem emitir um binário.

Na maior parte do tempo você não chama o compilador à mão — a sua ferramenta de build ou o seu editor faz isso e mostra os erros. Mas saber o que ele faz por baixo torna esses erros muito mais fáceis de ler.

Os compromissos honestos

Compiladores acrescentam um passo: você muda o código, espera o build, e depois executa. Num projeto grande essa espera pode incomodar, e por isso compiladores rápidos e builds incrementais importam. A recompensa é real: erros capturados cedo, saída otimizada e um único executável que você pode distribuir sem distribuir a sua toolchain. Para uma linguagem fortemente tipada como Haskell, essa verificação antecipada é grande parte do apelo — o compilador é uma rede de segurança, não apenas um tradutor.

Perguntas frequentes

Veja mais explicações claras no nosso índice de guias.