Keyboard shortcuts

Press ← or → to navigate between chapters

Press S or / to search in the book

Press ? to show this help

Press Esc to hide this help

Otimização (-o) e CTFE (@puro)

Passar -o ativa otimizações do compilador e -O2 no Clang/GCC. Regra de ouro do CGD: otimizar nunca pode mudar o comportamento observável, apagar efeitos ou esconder exceções.

Calculando resultados na compilação com @puro

Coloque o decorador @puro acima de uma função livre ou de um método estático que só depende dos próprios parâmetros. Com -o, quando ela for chamada com valores constantes, a VM interna do CGD calcula o resultado durante a compilação e substitui direto no código C gerado. A sintaxe antiga //>puro segue aceita por compatibilidade, mas @puro é a forma recomendada.

@puro
funcao fatorial(n: inteiro): inteiro {
    se n <= 1 { retorna 1 }
    retorna n * fatorial(n - 1)
}
const resultado: inteiro = fatorial(6) // já vira 720 com -o

O que o otimizador simplifica com segurança

O gerenciador de passes roda até atingir ponto fixo: dobra operações constantes (aritmética, unários, comparações, textos), propaga constantes tipadas com segurança, simplifica curto-circuito (verdadeiro e x, falso ou x) e remove caudas comprovadamente inalcançáveis — preservando blocos finalmente e efeitos colaterais.

Experimente: 26_ctfe

// A VM é usada na compilação, não na execução do binário final.
//>puro
funcao fibonacci(n: inteiro): inteiro {
    se n < 2 {
        retorna n
    }

    retorna fibonacci(n - 1) + fibonacci(n - 2)
}

escreva(fibonacci(10))

Ver exemplo completo e contrato de teste no GitHub

Experimente: 01_constantes_escopos

// A propagação usa a declaração resolvida, preservando o sombreamento.
const valor: numero = 2
se verdadeiro {
    const valor: numero = 9
    escreva(valor + 1)
}

escreva(valor + 1)

Ver exemplo completo e contrato de teste no GitHub

Experimente: 02_efeitos

// Mesmo com -o, multiplicar por zero não elimina a avaliação da função.
funcao calcular(): qualquer {
    escreva("efeito")
    retorna 7
}

escreva(calcular() * 0)

Ver exemplo completo e contrato de teste no GitHub

Experimente: 03_fluxo

// --verificar avisa sobre a cauda inalcançável; finalmente permanece em -o.
funcao resultado(): qualquer {
    tente {
        retorna (2 + 3) * 4
        escreva("inalcançável")
    } finalmente {
        escreva("limpeza")
    }
}

escreva(resultado())

Ver exemplo completo e contrato de teste no GitHub

Experimente: 04_curto_circuito

funcao proibida(): qualquer {
    falhar "Não deveria executar"
}

escreva(verdadeiro ? 7 : proibida(), falso e proibida(), verdadeiro ou proibida(), nulo ?: 8)

Ver exemplo completo e contrato de teste no GitHub

Experimente: 07_metodos_e_padroes

// Os passes também visitam métodos, valores padrão e funções anônimas.
classe Medida {
    dobro(valor: qualquer = 1 + 1): qualquer {
        retorna valor * 2
    }
}

var calcular: funcao = funcao(valor: qualquer = 3 + 4): qualquer {
    retorna valor
}

escreva(Medida().dobro(), calcular())

Ver exemplo completo e contrato de teste no GitHub

Experimente: 09_ctfe_fluxo_escopos

// A VM preserva senão, slots locais, parâmetros mutáveis e ordem de argumentos.
//>puro
funcao escolher(condicao: qualquer): qualquer {
    se condicao {
        retorna 1
    } senao {
        retorna 2
    }
}

//>puro
funcao combinar(a: qualquer, b: qualquer): qualquer {
    retorna a * 10 + b
}

//>puro
funcao calcular(): qualquer {
    var valor: numero = 1
    se verdadeiro {
        var valor: numero = 99
    }

    retorna combinar(valor++, valor++)
}

escreva(escolher(falso), calcular())

Ver exemplo completo e contrato de teste no GitHub

Experimente: 10_ctfe_excecao

// Uma falha da CTFE preserva a chamada para permitir tratamento em execução.
//>puro
funcao dividir(valor: qualquer): qualquer {
    retorna 1 / valor
}

tente {
    dividir(0)
} pegue (erro) {
    escreva("tratado")
}

Ver exemplo completo e contrato de teste no GitHub

Experimente: 11_ctfe_contrato

// A otimização não pode remover a validação de inteiro, nem em funções puras.
//>puro
funcao incrementar(valor: inteiro) {
    retorna valor + 1
}

escreva(incrementar(2.5))

Ver exemplo completo e contrato de teste no GitHub

Se uma função @puro ultrapassar o limite de passos na compilação ou lançar erro, o CGD simplesmente mantém a chamada normal em runtime. A sintaxe antiga //>puro continua funcionando por compatibilidade.