// referência do perfil compilado

A linguagem do CGD.

Como escrever cada recurso, o que já funciona e quais fronteiras permanecem. Esta é a referência própria da linguagem suportada pelo compilador, do primeiro programa às bibliotecas e contratos de execução. Os exemplos possuem contratos para testes com e sem otimização.

Referência original: Delégua, da Design Líquido e sua wiki oficial. Este guia descreve o perfil do CGD; não promete equivalência com todos os ambientes do interpretador.

25 capítulos

Com limites

Comece aqui: instalar, escrever e executar

CGD compila um perfil próprio de Delégua para C99 e usa memória gerenciada. Esta documentação descreve o compilador, suas bibliotecas e ferramentas; o interpretador original não é uma dependência de execução.

Ambiente e construção

O alvo validado é Linux x86_64. Instale DMD ou LDC2, DUB, Clang ou GCC, pkg-config, Python 3, headers do Boehm GC e libcurl >= 7.86. O runtime é um submódulo Git e deve acompanhar a revisão do compilador.

git submodule update --init --recursive
./build-runtime
dub build --compiler=ldc2 --build=release
./instalar

Seu primeiro programa

Salve como ola.delegua. A extensão do arquivo é parte do contrato da CLI. escreva termina com quebra de linha; vários argumentos são escritos em sequência, sem espaço implícito.

var nome = "Ana"
escreva("Olá, ${nome}!")

Verificar, compilar e otimizar

--verificar executa o frontend sem chamar compilador C. -s escolhe o executável de saída. -o habilita otimização e CTFE; não escolhe o caminho de saída. --emitir-c preserva o C intermediário sem executar o linker.

./cgd ola.delegua --verificar
./cgd ola.delegua -s out/ola
./out/ola
./cgd ola.delegua -o -s out/ola-otimizado
./cgd ola.delegua --emitir-c -s out/ola

Por que um perfil próprio?

A geração C99 e o runtime gerenciado dão um executável independente do interpretador. Os contratos precisam preservar efeitos, erros, tipos e aliases nos dois modos. Não se aceita código apenas porque outro ambiente Delégua o executa; os limites estão explícitos aqui.

Com limites

Editor: arquivos, cores, inferência e hover

A extensão VS Code usa um LSP local persistente. A edição não dispara build, linker, rede ou execução do programa.

Instalação e identidade visual

Com CGD e runtime construídos, prepare as dependências da extensão e use o instalador. A logo do projeto identifica arquivos .delegua nos temas que respeitam ícones de linguagem. Temas de ícones de terceiros podem sobrescrever esse ícone; não alteramos o tema global.

npm ci --prefix extensao-vscode --ignore-scripts
python3 scripts/instalar_extensao.py --associate

Coloração e formatação

Palavras-chave, tipos, atributos, métodos e decoradores recebem categorias semânticas. @definicao é formatado junto ao @; biblioteca, prefixo, simbolo e abi são argumentos de metadados. Strings e comentários não são reescritos. Ctrl+Shift+I usa o mesmo formatador da CLI, com quatro espaços.

@definicao(biblioteca="m", prefixo="")
classe estrangeira LibM {
    @definicao(simbolo="cos")
    cosseno(x: numero): numero;
}

Tipos inferidos são dicas virtuais

Em var quantidade = 3 o editor apresenta : numero após quantidade, sem gravar a anotação no arquivo. Variáveis já anotadas não recebem dica redundante. As dicas vêm do tipo resolvido, respeitam a revisão em memória e podem ser desligadas em cgd.inlayHints. A posição usa UTF-16 do protocolo LSP.

var quantidade = 3
var nome = "Ana"
var explicito: inteiro = 3

Pureza não é promessa de otimização

O hover informa se a função tem prova de pureza aprovada para CTFE. Uma chamada com resultado comprovado mostra a prévia. A substituição exige -o; sem otimização ela continua executando em runtime. Métodos, FFI, argumentos dinâmicos ou orçamento esgotado não recebem resultado inventado. Sem prova, a mensagem diz não comprovada, em vez de afirmar que todo código sem anotação tem efeitos.

Comandos explícitos

CGD: Verificar arquivo analisa o fonte; Compilar e executar faz build e abre um terminal. F5 é execução, não depuração. Depois de atualizar o VSIX, recarregue a janela. cgd.executable permite selecionar outro binário já construído; a extensão não baixa nem constrói um compilador ao abrir arquivos.

Com limites

Valores, tipos e variáveis

Use var para variáveis e const para vínculos constantes. As anotações aparecem após dois-pontos. Nulo, lógicos, números, textos, coleções, objetos e funções são valores gerenciados.

Declarações e inferência

var permite reatribuir; const exige um inicializador e impede reatribuir o vínculo. Uma coleção em const continua mutável, salvo um namespace de enum congelado. Anote com dois-pontos ou deixe o tipo ser inferido do inicializador.

var contador: inteiro = 0
var titulo = "CGD"
const limite: inteiro = 10

Tipos e limites

Recurso Contrato
numero / número Contrato numérico: aceita inteiro e real; inicializa com 0.
inteiro / longo Inteiro assinado de 64 bits. Overflow é falha tratável; longo não é bigint.
real / decimal Ponto flutuante de 64 bits; default 0.0. Não há precisão decimal financeira.
logico / booleano / binario Lógico; default falso.
texto UTF-8; default texto vazio. Índices contam pontos de código.
T[] Vetor com contrato de elemento; default vetor novo vazio.
dicionario / dicionário Mapa de chaves primitivas; default mapa novo vazio.
qualquer, classe, interface, funcao, tupla Sem instanciação implícita: ausência de inicializador permanece nulo. Tipos explícitos são conferidos nas atribuições/chamadas correspondentes.

Decisão: defaults previsíveis

Valores primitivos e coleções têm um estado inicial útil sem depender do construtor. Objetos e funções não são construídos automaticamente: isso poderia executar código, falhar ou criar dependências inesperadas. Inicializadores explícitos sempre prevalecem.

linguagem/01_tipos.delegua

Abrir fonte e contrato de teste

// Declaração, valores primitivos e tipo de em execução.
var vazio: qualquer
const ativo: logico = verdadeiro
var idade: inteiro = 20
var medida: real = 2.5
escreva(vazio, ativo)
escreva(tipo de idade, " ", tipo de medida, " ", tipo de "olá", " ", tipo de ativo)
linguagem/03_atribuicoes.delegua

Abrir fonte e contrato de teste

var a: numero, b: numero = 1, 2
a, b = b, a // Os valores da direita são avaliados antes das escritas.
var contador: numero = 2
contador += 5
escreva(a, b, contador)
var destino: numero = 0
escreva(destino = 5)
linguagem/25_escopos.delegua

Abrir fonte e contrato de teste

var x: numero = 1
se verdadeiro {
    var x: numero = 2;
    escreva(x)
}

escreva(x)
funcao criar(): qualquer {
    retorna auxiliar
    funcao auxiliar(x: qualquer): qualquer {
        retorna x * 2
    }
}

escreva(criar()(4))

Constante impede reatribuir o vínculo; coleções continuam tendo sua mutabilidade própria. Inteiros/longo têm 64 bits e reais/decimal usam ponto flutuante de 64 bits. Não há bigint.

Disponível

Operadores e ordem de avaliação

Aritmética, potência, divisão inteira, bits, comparações, pertencimento, atribuições compostas e incremento. Os argumentos e índices são avaliados na ordem da fonte.

Comparações textuais

<, <=, > e >= entre textos usam ordem lexicográfica dos pontos de código Unicode em UTF-8 válido, incluindo textos com zero interno. Prefixo mais curto vem antes. Não há ordenação por idioma, normalização ou comparação sem acentos. Runtime, dobras de literais e CTFE compartilham o resultado.

var ch: texto = '5'
se ch >= '0' e ch <= '9' { escreva('dígito ASCII') }
escreva('ação' > 'a')

Efeitos e precedência

Operandos, receptor e argumentos mantêm a ordem da fonte. e/ou/?: avaliam apenas o lado necessário. Atribuições compostas e incrementos avaliam o destino uma vez. Comparações misturando texto e número não fazem conversão textual silenciosa. Use parênteses quando a intenção de precedência não ficar clara.

linguagem/02_operadores.delegua

Abrir fonte e contrato de teste

// Potência, divisão inteira, bits, comparação e curto-circuito.
escreva(2 ** 5, 100 \ 3, 5 & 3, 1 << 0)
escreva(3 != 4, falso e(1 / 0), nulo ?: 10)
linguagem/35_bits_e_atribuicoes.delegua

Abrir fonte e contrato de teste

var n: numero = 8
escreva(n | 1, n >> 3)
escreva(3 ^ 2, ~1, 5 & 3)
var a: numero = 9
a -= 1
a *= 2
a /= 4
a %= 3
escreva(++ a + 1)

e/ou retornam o valor selecionado. 0, texto vazio e coleções vazias são verdadeiros; falso e nulo são falsos. ?: troca somente nulo. Overflow e divisão por zero lançam exceção.

Disponível

Condições, escolha e laços

se/senão, ternário, escolha/caso/padrão, enquanto, fazer/enquanto, para, para cada, sustar e continua controlam o fluxo.

Blocos e desvios

Blocos usam chaves. se/senao e escolha/caso selecionam comandos. sustar sai do laço/escolha; continua passa à próxima iteração. finalmente ainda executa em transferências de controle. Um comando depois de retorno ou falha pode gerar aviso de código inalcançável.

Iteração com tipo

para cada elem: T em coleção valida o vínculo a cada iteração. Vetores produzem elementos; texto produz caracteres por ponto de código; dicionários produzem pares chave/valor. Desestruturações e compreensões também aceitam tipos. Não se promete snapshot quando a coleção é alterada durante a própria iteração.

var valores: inteiro[] = [1, 2, 3]
para cada valor: inteiro em valores { escreva(valor) }
linguagem/04_condicionais.delegua

Abrir fonte e contrato de teste

var idade: numero = 20
escreva(idade >= 18 ? "adulto": "menor")
escolha 2 {
    caso 1: escreva("um")
    caso 2:
    caso 3: escreva("dois ou tres")
    padrao: escreva("outro")
}
linguagem/05_lacos.delegua

Abrir fonte e contrato de teste

para (var i: numero = 0; i < 4; i++) {
    se i == 1 {
        continua
    }

    se i == 3 {
        sustar
    }

    escreva(i)
}

fazer {
    escreva("feito")
}

enquanto falso
var soma: numero = 0
para cada item: inteiro em [1, 2, 3] {
    soma += item
}

escreva(soma)
linguagem/34_lacos_variantes.delegua

Abrir fonte e contrato de teste

var i: numero = 0
var primeiro: qualquer[] = fazer {
    i++;
    retorna i
}

enquanto i < 2
var segundo: qualquer[] = para cada valor: inteiro em [1, 2] {
    retorna valor * 2
}

var terceiro: qualquer[] = enquanto i > 0 {
    retorna i--
}

escreva(primeiro)
escreva(segundo)
escreva(terceiro)

Disponível

Laços como expressões

Um laço usado como expressão constrói um vetor. retorna dentro do coletor contribui um valor ao resultado; o compilador distingue esse retorno do retorno da função.

Construir um vetor com um laço

Laços usados como expressão acumulam valores. retorna dentro do corpo coletor acrescenta ao resultado, em vez de sair da função externa. Condições, efeitos e finalmente continuam em ordem; sustar encerra a coleta e continua passa à próxima iteração.

var quadrados = para (var i: inteiro = 0; i < 4; i++) { retorna i*i }
escreva(quadrados)

Coleta não é execução antecipada

Uma expressão de laço é executada no programa, a menos que um passe especificamente prove uma simplificação segura. Capturas não são necessárias para construir o resultado e o código não é executado pelo editor.

linguagem/06_lacos_resultado.delegua

Abrir fonte e contrato de teste

// Retornos dentro de uma expressão de laço acumulam os valores.
var quadrados: qualquer[] = para (var i: numero = 0; i < 4; i++) {
    retorna i * i
}

var i: numero = 0
var pares: qualquer[] = enquanto i < 3 {
    i++;
    retorna i * 2
}

escreva(quadrados)
escreva(pares)

Disponível

Funções e parâmetros

Declare funções nomeadas ou anônimas; passe funções como argumentos, retorne funções sem captura e use métodos ligados. Valores padrão são avaliados no chamado e podem usar parâmetros anteriores. ... recebe argumentos variáveis.

Parâmetros e retornos

Use funcao/função, argumentos tipados opcionais e retorno após dois-pontos. Parâmetros opcionais devem vir depois dos obrigatórios; o espalhamento deve ser o último. Um parâmetro padrão pode usar parâmetros anteriores. Sem retorna, o valor final é nulo, não a última expressão.

funcao somar(a: inteiro, b: inteiro = 1): inteiro {
    retorna a + b
}
var duplicar: funcao = (x: inteiro): inteiro => x * 2

Sem captura implícita

Funções e arrows podem ser valores e callbacks. Não carregam variáveis do ambiente externo: passe os dados por parâmetros. Capturas geram aviso e erro. Métodos ligados mantêm seu receptor explicitamente gerenciado. Esta decisão evita introduzir um ambiente de closures com semântica parcial.

linguagem/07_funcoes.delegua

Abrir fonte e contrato de teste

funcao soma(a: inteiro, b: inteiro = a + 2): inteiro {
    retorna a + b
}

funcao reunir(primeiro: qualquer, ... resto: qualquer): qualquer {
    retorna [primeiro, ... resto]
}

escreva(soma(3))
escreva(reunir(1, ...[2, 3]))
linguagem/08_funcoes_valores.delegua

Abrir fonte e contrato de teste

funcao dobro(x: qualquer): qualquer {
    retorna x * 2
}

var operacao: funcao = dobro
funcao criar(): qualquer {
    // Esta função não captura nenhuma variável de criar().
    retorna funcao(x: qualquer): qualquer {
        retorna x + 4
    }
}

escreva(operacao(3))
escreva(criar()(5))
escreva(mapear([1, 2, 3], funcao(x: qualquer): qualquer {
    retorna x * 3
}))

Capturas de variáveis externas são bloqueadas. Passe o estado explicitamente por parâmetros; um método ligado mantém apenas seu receptor gerenciado.

Disponível

Vetores, compreensão e fatias

Vetores são mutáveis. Há índices negativos, espalhamento, compreensão com filtro e fatiamento com passo. Contratos de tipos continuam válidos através de aliases.

Literais, spread e compreensão

Use [a, b] para vetor; ... espalha elementos. Compreensão filtra e transforma em um novo vetor, sem mudar a coleção original. O vínculo de iteração pode ter anotação.

var original: inteiro[] = [1, 2, 3]
var copia: inteiro[] = [...original, 4]
var pares = [x*2 para cada x: inteiro em original se x > 1]

Fatias e métodos

v[inicio:fim:passo] usa fim exclusivo. Início/fim podem ser omitidos, passo pode ser negativo e zero é inválido. Métodos incluem adicionar/empilhar, remover, removerPrimeiro/removerUltimo, inverter, somar, juntar, concatenar, encaixar, ordenar, mapear e filtrarPor. As operações que mutam atuam sobre aliases da mesma coleção; fatiar e concatenar produzem resultados próprios. Callbacks são funções sem captura.

linguagem/09_vetores.delegua

Abrir fonte e contrato de teste

var valores: qualquer[] = [3, 1, 2]
valores.ordenar()
escreva(valores, valores.somar())
var removidos: qualquer = valores.encaixar(1, 1, 7, 8)
escreva(removidos, valores)
linguagem/10_compreensao_fatias.delegua

Abrir fonte e contrato de teste

var valores: qualquer[] = [1, 2, 3, 4, 5]
escreva([x * 3 para cada x: inteiro em valores se x % 2 == 0])
escreva(valores[: : - 1], valores[: : 2])
linguagem/22_contratos_aliases.delegua

Abrir fonte e contrato de teste

var numeros: inteiro[] = [1]
var alias: qualquer = numeros
tente {
    alias.adicionar("texto")
}
pegue {
    escreva("bloqueado")
}

escreva(numeros)
linguagem/30_metodos_vetor.delegua

Abrir fonte e contrato de teste

var v: qualquer[] = [1, 2]
v.empilhar(3)
escreva(v.concatenar([4]).ordenar(funcao(a: qualquer, b: qualquer): qualquer {
    retorna b - a
}))
v.adicionar(4)
escreva(v.removerPrimeiro(), v.removerUltimo())
escreva(v.removerUltimo())
escreva(v.removerPrimeiro())
escreva([1, 2, 3].filtrarPor(funcao(x: qualquer): qualquer {
    retorna x < 3
}).mapear(funcao(x: qualquer): qualquer {
    retorna x * 3
}))

Métodos: adicionar, empilhar, tamanho, inclui/contem/contém, fatiar, mapear, filtrarPor, remover, removerPrimeiro, removerUltimo, inverter, somar, juntar, concatenar, encaixar e ordenar. Restrições por aliases são monotônicas; modificar durante a iteração não cria snapshot. filtrar global recebe vetor e função; não existe método reduzir neste perfil.

Disponível

Dicionários, tuplas e clonagem

Dicionários associam chaves a valores; tuplas são imutáveis. Desestruture propriedades e use propriedades ordinais de tuplas. clonar copia grafos e preserva ciclos.

Chaves, pares e presença

Dicionários usam chaves nulas, lógicas, numéricas ou textuais. A chave 1 e a chave 1.0 identificam a mesma entrada; verdadeiro é uma chave diferente. Chaves numéricas não finitas são rejeitadas. A ordem de iteração não é ordem de inserção prometida.

var dados: dicionario = { nome: "Ana", ativo: nulo }
escreva(dados.obter("nome", "sem nome"))
escreva(dados.contemChave("ativo"))
para cada par: qualquer em dados { escreva(par[0], par[1]) }

Tuplas, desestruturação e cópia

Literais como (1, "a") criam tuplas imutáveis; tupla(vetor) converte coleções de 2 a 10 elementos. Propriedades ordinais como primeiro e segundo dão acesso aos membros. Desestruturação const { nome: texto } = dados cria um vínculo, sem copiar profundamente o objeto. clonar suporta ciclos e mantém identidades compartilhadas dentro da cópia; não clona código de função nem abre outro recurso nativo.

linguagem/11_dicionarios.delegua

Abrir fonte e contrato de teste

var original: dicionario = { a: 1 }

var dados: dicionario = { ... original, b: 2 }
// dados.obter("b")

const { a: qualquer, b: qualquer } = dados
escreva(a, b)

para cada { chave: texto, valor: inteiro } em { x: 7 } {
    escreva(chave, valor)
}

escreva("a" em dados)
linguagem/12_tuplas.delegua

Abrir fonte e contrato de teste

// Tuplas possuem acesso por índice e por propriedades ordinais.
var tuplaLiteral: tupla = [(1, "texto")]
var tipada: (numero, texto) = tupla([2, "outro"])
escreva(tuplaLiteral[0], tuplaLiteral.segundo)
escreva(tipada)
linguagem/20_clonagem.delegua

Abrir fonte e contrato de teste

var original: dicionario = { dados: [1] }

var copia: qualquer = clonar(original)
copia.dados.adicionar(2)
escreva(original.dados, copia.dados)
var ciclo: qualquer[] = []
ciclo.adicionar(ciclo)
var clonado: qualquer = clonar(ciclo)
escreva(clonado[0] == clonado)
linguagem/31_metodos_dicionario.delegua

Abrir fonte e contrato de teste

var d: dicionario = { b: 2, a: 1 }

escreva(d.chaves().ordenar().juntar("-"), d.valores().ordenar())
escreva(d.contém("a"), d.remover("a"), d.tamanho())
escreva(d.obter("a"))
linguagem/37_dicionario_obter.delegua

Abrir fonte e contrato de teste

var dados: dicionario = { "presente": nulo }
escreva(dados.obter("ausente", 42))
escreva(dados.obter("presente", 42))
escreva(dados.contemChave("presente"))
dados.definir("nome", "CGD")
var itens: qualquer[] = dados.itens()
dados.limpar()
escreva(tamanho(itens))
escreva(tamanho(dados))

Dicionários: chaves, valores, tamanho, remover e inclui/contem/contém. Tuplas: tamanho, inclui/contem/contém e fatiar, além das propriedades ordinais demonstradas. A iteração de dicionários não garante ordem de inserção. Dicionários também oferecem obter(chave, padrão), definir, contemChave, itens e limpar. Nulo armazenado não é ausência.

Disponível

Texto, Unicode e interpolação

Textos usam UTF-8. Tamanho, índices e fatias contam pontos de código. Interpole expressões com ${...} e use escapes; mudanças de caixa seguem as tabelas Unicode do runtime.

Unicode e índices

Textos preservam UTF-8 e indexam pontos de código, não bytes nem grafemas. A letra com acento combinante pode ocupar mais de um índice. tamanho conta pontos de código; I/O mede limites em bytes. Não há normalização Unicode automática: preservar os dados evita modificar identificadores, mensagens e conteúdo externo.

Interpolação e escapes

${expressao} insere o valor textual da expressão e preserva a ordem de avaliação. Aspas simples e duplas delimitam texto. Escapes incluem quebra de linha, tabulação, barra e zero interno. O formatador conserva o literal exatamente.

var nome: texto = "Ana"
escreva("Olá, ${nome}\n")
escreva("ação"[1])

Métodos de texto

tamanho, inclui/contem/contém, fatiar/subtexto, aparar/apararInicio/apararFim, maiusculo/minusculo, tudoMaiusculo/tudoMinusculo, encontrar, dividir, substituir e concatenar compõem a API textual. Operações de caixa usam Unicode. Encontrar retorna posição por pontos de código. As comparações são lexicográficas; para ordens por idioma use uma biblioteca explicitamente adequada.

linguagem/13_texto_unicode.delegua

Abrir fonte e contrato de teste

escreva(tamanho("ação"), "ação"[1], "ação"[1: 3])
escreva("  Olá árvore  ".aparar().maiusculo())
var n: numero = 2
escreva("valor ${n + 1}")
linguagem/28_metodos_texto.delegua

Abrir fonte e contrato de teste

// Busca, divisão, substituição e testes de caixa.
escreva("  a".apararInicio(), "á  ".apararFim())
escreva("a,b".dividir(","), "ação".substituir("ç", "s"))
escreva("ABC".tudoMaiusculo(), "abc".tudoMinusculo())

Métodos: tamanho, inclui/contem/contém, fatiar/subtexto, aparar, apararInicio, apararFim, maiusculo/tudoMaiusculo, minusculo/tudoMinusculo, encontrar, dividir, substituir e concatenar. Pontos de código não equivalem a grafemas visuais.

Com limites

Classes, herança e acessores

Declare campos e métodos; inicialize com construtor, acesse o receptor por isto e a implementação herdada por super. Visibilidades público, privado e protegido usam a classe lexical.

Atributos e inicializadores

Atributos têm tipo e podem ter valor na própria classe. Cada instância recebe seus próprios defaults e coleções; a expressão explícita é reavaliada para cada objeto. Primeiro são inicializados os campos da base, depois os da derivada, em ordem de declaração; em seguida executa o construtor selecionado. isto permite ler membros já inicializados. O inicializador escreve o armazenamento inicial diretamente, sem disparar um setter customizado.

classe Contador {
    valor: inteiro = 1
    historico: inteiro[]
    incrementar(): vazio { isto.valor++ }
}
var a: Contador = Contador()
var b: Contador = Contador()
a.historico.adicionar(3) // b.historico continua vazio

Herança e ciclo de vida

herda aceita uma classe base. Métodos públicos/protegidos são resolvidos com sua visibilidade; privado pertence à classe declaradora. super chama a implementação da base. O construtor da base deve ser chamado explicitamente quando necessário. destruir(objeto) percorre destrutores da derivada às bases uma vez por identidade, mesmo se houver exceção; o primeiro erro é relançado. O GC gerencia memória, mas não executa destrutores Delégua.

Por que esses limites?

Campos estáticos não são suportados; métodos estáticos não recebem isto. Classes só existem no módulo. O compilador preserva acesso, contratos e aliases em C. Não se inventa um construtor ao ler um campo tipado sem inicializador de objeto: ele começa nulo.

linguagem/14_classes.delegua

Abrir fonte e contrato de teste

classe Ponto {
    x: numero

    construtor(x: numero) {
        isto.x = x
    }

    dobro(): qualquer {
        retorna isto.x * 2
    }
}

var ponto: Ponto = Ponto(3)
escreva(ponto.x, ponto.dobro())
ponto.x = 4
escreva(ponto.dobro())
linguagem/15_heranca.delegua

Abrir fonte e contrato de teste

classe Base {
    protegido {
        x: numero
    }

    construtor(x: qualquer) {
        isto.x = x
    }

    valor(): qualquer {
        retorna isto.x
    }
}

classe Filha herda Base {
    construtor(x: qualquer) {
        super(x + 1)
    }

    valor(): qualquer {
        retorna super.valor() * 2
    }

    dado(): qualquer {
        retorna isto.x
    }
}

var filha: Filha = Filha(3)
var metodo: funcao = filha.valor // Receptor explícito, gerenciado pelo GC.
escreva(metodo(), filha.dado())
escreva(filha.eInstanciaDe(Base))
linguagem/16_privacidade_acessores.delegua

Abrir fonte e contrato de teste

classe Conta {
    privado {
        _saldo: numero
    }

    saldo: numero {
        obter() {
            retorna isto._saldo
        }
        definir(valor: qualquer) {
            isto._saldo = valor * 2
        }
    }

    construtor() {
        isto._saldo = 0
    }
}

var conta: Conta = Conta()
conta.saldo = 3
escreva(conta.saldo)
linguagem/32_objeto_e_metodos.delegua

Abrir fonte e contrato de teste

classe Pessoa {
    nome: texto

    construtor(nome: qualquer) {
        isto.nome = nome
    }

    paraTexto(): qualquer {
        retorna "Pessoa: ${isto.nome}"
    }
}

var p: Pessoa = Pessoa("Ada")
escreva(p.tipo())
escreva(p.respondeA("paraTexto"), p.eInstanciaDe(Objeto))
escreva(p)
linguagem/36_destrutores.delegua

Abrir fonte e contrato de teste

classe Base {
    destrutor(): vazio {
        escreva("base")
    }
}

classe Filha herda Base {
    destrutor(): vazio {
        escreva("filha")
    }
}

var recurso: Filha = Filha()
tente {
    assercao(verdadeiro)
} finalmente {
    destruir(recurso)
}

destruir(recurso)
escreva("fim")
linguagem/39_inicializacao.delegua

Abrir fonte e contrato de teste

var n: numero
var texto: texto
var logico: logico
escreva(n, texto, logico)
classe Base {
    valor: inteiro = 7
    itens: inteiro[]
}

classe Filha herda Base {
    copia: inteiro = isto.valor
}

var primeira: Filha = Filha()
var segunda: Filha = Filha()
primeira.itens.adicionar(1)
escreva(primeira.copia)
escreva(tamanho(segunda.itens), tamanho(primeira.itens))
var ch: texto = "5"
escreva(ch >= '0' e ch <= '9', "ação" > "a")

Classes devem estar no nível do módulo. Campos são declarados; não há injeção arbitrária de campos. Herança por alias dinâmico de classe importada e tipos locais não têm resolução completa. Destrutores explícitos via destruir(instancia), da derivada às bases; idempotência por identidade, sem chamadas pelo GC ou ao sair do escopo.

Disponível

Exceções e limpeza

Use tente, pegue, finalmente e falhar. Excecao possui mensagem; subclasses podem ser tratadas por tipo. Finalmente executa também em retornos e desvios de laços.

Lançar, capturar e limpar

falhar aceita um erro ou valor convertido em Excecao. pegue pode ter vínculo e tipo; finalmente roda também em retorno, sustar, continua e nova falha. O caminho que propaga o erro conserva o valor de exceção; a localização vem da operação falível.

tente {
    falhar "entrada inválida"
} pegue (erro: Excecao) {
    escreva(erro.mensagem)
} finalmente {
    escreva("limpeza")
}

Decisão: falha observável

Otimizações não apagam exceções nem executam um lado descartado de curto-circuito. Falha constante em região deliberadamente capturada recebe aviso estático quando suportado. R0001 agrupa erros dinâmicos; ainda não há uma pilha Delégua completa. Recursos externos devem ser fechados explicitamente ou em finalmente, sem depender do GC.

linguagem/17_excecoes.delegua

Abrir fonte e contrato de teste

tente {
    falhar "proposital"
} pegue (erro: Excecao) {
    escreva(erro.mensagem)
} finalmente {
    escreva("limpeza")
}

tente {
    escreva(1 / 0)
} pegue (erro) {
    escreva(erro)
}
linguagem/18_finalmente_retorno.delegua

Abrir fonte e contrato de teste

funcao obter(): qualquer {
    tente {
        retorna 3
    } finalmente {
        escreva("fim")
    }
}

escreva(obter())
para (var i: numero = 0; i < 2; i++) {
    tente {
        continua
    } finalmente {
        escreva("loop")
    }
}
linguagem/19_excecoes_tipadas.delegua

Abrir fonte e contrato de teste

classe MeuErro herda Excecao {
}

tente {
    falhar MeuErro("meu erro")
}
pegue (erro: MeuErro) {
    escreva(erro)
}
pegue {
    escreva("outro erro")
}

Falhas do runtime são tratáveis. Sem tratador, o processo termina com status 1. Há localização, mas ainda não uma pilha completa de chamadas Delégua. A localização usa descritores estáticos apenas nas operações falíveis; literais e declarações simples não recebem chamadas de localização. R0001 é o código genérico atual de falha dinâmica.

Disponível

Módulos estáticos

importar recebe caminho literal .delegua, relativo ao módulo que importa. O loader canonicaliza, reutiliza unidades, mostra a cadeia de ciclos e impõe limites de recursos.

Importação literal e namespace

importar recebe um caminho literal .delegua relativo ao módulo importador, ou um alias de biblioteca cgd:. A unidade é carregada na compilação, inicializada uma vez na execução e acessada como namespace. Não são importados pacotes NPM, código baixado ou nomes computados.

var biblioteca: qualquer = importar("cgd:json")
var documento: qualquer = biblioteca.JSON.deTexto("{}")

Identidade, ciclos e visibilidade

O carregador canonicaliza caminhos, aplica orçamento e detecta ciclos com cadeia de importação. Arquivos abertos em memória prevalecem sobre disco no LSP. Tipos de classes possuem identidade de declaração; um nome igual em outro módulo não é o mesmo tipo. Herança por alias dinâmico de classe importada não é resolvida. A ausência de busca irrestrita no disco torna o trabalho do editor limitado e previsível.

modulos/01_importacao.delegua

Abrir fonte e contrato de teste

var calculos: qualquer = importar("lib/calculos.delegua")
var outraReferencia: qualquer = importar("./lib/calculos.delegua")
escreva(calculos.soma(3), outraReferencia.versao, calculos.Valor(4).dado)
compilador/08_otimizacao_modulos.delegua

Abrir fonte e contrato de teste

// As duas importações compartilham o módulo, sem repetir inicialização.
var primeiro: qualquer = importar("biblioteca.delegua")
var segundo: qualquer = importar("biblioteca.delegua")
escreva(primeiro.dobro(2 + 2))

Inicialização é única; se falhar, permite nova tentativa. Exportações não podem ser substituídas. Importação dinâmica, NPM e código estrangeiro são excluídos.

Disponível

Biblioteca nativa e entrada/saída

escreva, leia, tamanho, inteiro, numero/número, real, texto, tupla, clonar, aleatorio, aleatorioEntre, mapear, filtrar, ordenar, paraCada e todosEmCondicao compõem a biblioteca global.

Entrada e saída básicas

escreva formata valores e termina a linha; leia lê uma linha da entrada padrão, com mensagem opcional. texto, inteiro, real e numero são conversões explícitas e podem falhar. Para arquivos e HTTP, use as classes de biblioteca documentadas, não uma função global inventada.

var entrada: texto = leia("Idade: ")
tente { escreva(inteiro(entrada)) } pegue { escreva("inteiro inválido") }

Operações gerais

tamanho consulta coleções/texto; clonar copia dados; mapear, filtrar, paraCada, todosEmCondicao e ordenar recebem callbacks sem captura. aleatorio produz real em [0, 1); aleatorioEntre usa limite superior exclusivo. decoradores devolve cópia dos metadados. tipo de é uma expressão para consultar a categoria do valor. Métodos nativos são sugeridos pelo tipo do receptor, nunca por uma lista global após ponto.

linguagem/21_biblioteca.delegua

Abrir fonte e contrato de teste

escreva(inteiro("12"), real(".5"), 1234.5689.formatar())
funcao par(x: qualquer): qualquer {
    retorna x % 2 == 0
}

escreva(filtrar([1, 2, 3, 4], par), todosEmCondicao([2, 4], par))
paraCada([1, 2], funcao(x: qualquer): qualquer {
    escreva(x * 2)
})
linguagem/27_entrada.delegua

Abrir fonte e contrato de teste

var nome: texto = leia("Nome: ")
escreva("Olá, ${nome}")
linguagem/29_metodos_numero.delegua

Abrir fonte e contrato de teste

escreva((- 3).absoluto(), (2.3).arredondarParaCima(), 2.5.formatar(2))
escreva(1234.5689.formatar({ minimoCasasDecimais: 2, maximoCasasDecimais: 3 }))
linguagem/33_aleatoriedade.delegua

Abrir fonte e contrato de teste

// A saída é determinística: verificamos os intervalos, não um valor sorteado.
para (var i: numero = 0; i < 100; i++) {
    var real: real = aleatorio()
    var inteiro: numero = aleatorioEntre(- 3, 4)
    assercao real >= 0 e real < 1
    assercao inteiro >= - 3 e inteiro < 4
}

escreva("intervalos validados")

Números: absoluto, arredondarParaBaixo, arredondarParaCima e formatar. As bibliotecas de delegua-node não são automaticamente módulos do CGD. leia usa stdin; o catálogo inclui entrada de teste reproduzível.

Com limites

Decoradores e asserções

Decoradores registram metadados; decoradores(valor) devolve cópias desses dados. Envelopes de funções livres podem trocar a função, desde que não capturem ambiente. Asserções lançam exceções tratáveis.

Metadados declarativos

@nome ou @nome(chave=valor) associa dados a funções/classes/campos/métodos. Argumentos precisam ser constantes, sem executar chamadas. @definicao tem significado adicional nas classes estrangeiras e declara a fronteira ABI; seus argumentos não são uma expressão de carregamento dinâmico.

@descricao(nome="Exemplo")
classe Exemplo { valor: inteiro = 1 }
escreva(decoradores(Exemplo))

Envelopes e asserções

Envelopes de funções livres podem substituir a função sem capturar o ambiente. Envelopes em métodos não são suportados; metadados em métodos são aceitos. assercao/asserção verifica uma condição e lança erro tratável com mensagem opcional.

assercao(2+2 == 4, "contrato aritmético")

Decisão: metadados não são eval

O formato dos decoradores é analisável estaticamente e preserva autoria/posição. Código do programa não pode ser executado no frontend só para obter argumentos ou descobrir tipos. Asserções também não desaparecem apenas porque a otimização está habilitada.

linguagem/23_decoradores.delegua

Abrir fonte e contrato de teste

@minimo(valor = 0)
classe Medida {
    lado: numero
}

escreva(decoradores(Medida).classe[0].nome)
funcao alternativa(): qualquer {
    retorna 9
}

funcao de decorador trocar(original: qualquer): qualquer {
    retorna alternativa
}

@trocar
funcao obter(): qualquer {
    retorna 1
}

escreva(obter())
linguagem/24_assercoes.delegua

Abrir fonte e contrato de teste

assercao 2 + 2 == 4
escreva("validado")
tente {
    asserção(falso, "mensagem personalizada")
}
pegue (erro) {
    escreva(erro)
}

Envelopes em métodos ainda são rejeitados. Metadados em métodos, classes e campos são suportados. Asserções não são removidas por -o.

Com limites

Otimização e avaliação em compilação

-o habilita passes até ponto fixo. Literais, constantes por identidade, ramos mortos e curto-circuito são simplificados preservando efeitos. //>puro habilita CTFE em uma VM com orçamento.

Optar por CTFE

//>puro marca uma função livre para análise de pureza e de representabilidade na VM. Argumentos precisam ter representação constante; resultados passam por contratos. A VM limita instruções, recursão, operandos, slots e tamanho de texto. Falhas não são suprimidas: uma chamada não dobrável continua em runtime, permitindo o tratamento de exceções.

//>puro
funcao quadrado(x: inteiro): inteiro { retorna x*x }
var resultado = quadrado(7)

Correção antes de simplificação

-o busca ponto fixo medindo mudanças. Não descarta inicializadores ou escritas só porque seu resultado não aparece depois. Identidades como f()*0 não podem apagar f(). O hover é uma prévia limitada e não executa FFI, rede ou I/O. Métodos ainda não têm avaliação CTFE suportada.

linguagem/26_ctfe.delegua

Abrir fonte e contrato de teste

// 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))
compilador/01_constantes_escopos.delegua

Abrir fonte e contrato de teste

// 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)
compilador/02_efeitos.delegua

Abrir fonte e contrato de teste

// 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)
compilador/03_fluxo.delegua

Abrir fonte e contrato de teste

// --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())
compilador/04_curto_circuito.delegua

Abrir fonte e contrato de teste

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

escreva(verdadeiro ? 7: proibida(), falso e proibida(), verdadeiro ou proibida(), nulo ?: 8)
compilador/07_metodos_e_padroes.delegua

Abrir fonte e contrato de teste

// 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())
compilador/09_ctfe_fluxo_escopos.delegua

Abrir fonte e contrato de teste

// 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())
compilador/10_ctfe_excecao.delegua

Abrir fonte e contrato de teste

// 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")
}
compilador/11_ctfe_contrato.delegua

Abrir fonte e contrato de teste

// 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))

A VM preserva senão, escopos, parâmetros mutáveis e a ordem dos argumentos, além de validar contratos primitivos de parâmetros, locais e retorno. Limites, falhas e valores não representáveis mantêm a chamada nativa. Há diagnóstico para recursos fora do subconjunto CTFE. Não há backend próprio LLVM/assembly.

Com limites

Diagnósticos e ferramentas

--verificar analisa sem gerar binário. --emitir-c gera C99 sem exigir linker/runtime instalado. --diagnosticos=json produz JSON Lines em stderr, com código, severidade, mensagem, explicação e intervalo. --explicar E3101 consulta o catálogo central sem compilar.

Encontrar a causa

Diagnósticos incluem severidade, código, arquivo e intervalo. --diagnosticos=json serve ferramentas; --explicar CODIGO explica o catálogo. Falhas comprovadas em região protegida por pegue recebem avisos W31xx para preservar o tratamento deliberado. Dados externos continuam validados no runtime. R0001 é a categoria dinâmica genérica, não uma pilha completa de chamadas.

./cgd programa.delegua --verificar --diagnosticos=json
./cgd --explicar E3101

Recuperação e limites

O parser tenta reportar erros independentes e o LSP tolera edições incompletas. Fontes, nós, profundidade e módulos têm orçamentos defensivos. Erros de tipos/escopo não são adiados até C para parecer que a análise passou. Avisos não equivalem a uma prova global de segurança.

compilador/05_diagnosticos.delegua

Abrir fonte e contrato de teste

// Dois erros independentes: o parser recupera e reporta os dois.
var primeiro: qualquer =;
var segundo: qualquer =;
compilador/06_sugestao.delegua

Abrir fonte e contrato de teste

var mensagem: texto = "Olá"
escreva(mensage)
compilador/12_divisao_estatica.delegua

Abrir fonte e contrato de teste

const zero: inteiro = 3 - 3
escreva(10 / zero)
compilador/13_indice_unicode.delegua

Abrir fonte e contrato de teste

// 'ação' tem quatro pontos de código; o maior índice positivo é 3.
escreva("ação"[4])
compilador/14_falha_tratada.delegua

Abrir fonte e contrato de teste

// Uma operação deliberadamente inválida dentro de pegue recebe aviso W3101.
// A exceção continua tratável, e a localização não exige chamada por linha.
tente {
    escreva(1 / 0)
} pegue (erro) {
    escreva("tratado")
}

Catálogo de diagnósticos

Gerado do catálogo central do compilador. Consulte também cgd --explicar E3101. Os códigos W3101–W3108 são as versões em aviso das respectivas falhas E31xx em regiões com tratador.

Código Mensagem / modelo Referência
E0001 %s Diagnóstico legado; consulte a mensagem e a posição.
E0002 Limite de diagnósticos atingido; corrija os erros anteriores. O limite protege contra uma cascata de erros.
E1000 Fim inesperado do arquivo; verifique delimitadores e expressões incompletas. Feche os delimitadores e complete a última expressão.
E1001 %s A mensagem descreve o token ou expressão esperado; o parser tenta recuperar em outro comando.
E1002 Arquivo fonte não contém UTF-8 válido. Salve a fonte como UTF-8.
E1003 Limite de aninhamento sintático excedido. Divida expressões ou blocos profundamente aninhados.
E1004 Limite estrutural da AST excedido; divida a expressão ou o módulo. O frontend limita profundidade e quantidade de nós antes dos passes recursivos.
E1005 Literal numérico inválido ou fora do intervalo. Literais inteiros exigem 64 bits; literais reais precisam ser finitos e representáveis em 64 bits.
E2001 Ciclo de importação detectado: %s Quebre a dependência circular mostrada pela cadeia de importação.
E2002 Limite de recursos de carregamento de módulos excedido. Divida o grafo; os limites de tamanho e quantidade são documentados.
E2003 %s Importado por: %s Confira o caminho literal relativo ao módulo que importa.
E3001 O símbolo '%s' não foi declarado. Verifique escopo e grafia; funções não capturam ambientes externos.
E3002 Incompatibilidade de tipo: era esperado '%s' mas foi recebido '%s'. Use um tipo compatível com o contrato declarado.
E3011 Campos estáticos ainda não são suportados; declare um método estático. Esta versão oferece campos de instância e métodos estáticos; a ausência de campos estáticos não é uma exclusão de segurança.
E3012 Construtor não pode ser estático. O construtor inicializa uma instância gerenciada e recebe isto; use outro nome para uma fábrica estática.
E3013 Destrutor deve ser público, de instância, sem parâmetros e retornar vazio. Declare destrutor(): vazio e use destruir(objeto) em finalmente para liberar recursos explicitamente.
E3014 Membro '%s' não é acessível neste contexto. Respeite a visibilidade público, protegido ou privado da declaração que oculta as herdadas.
E3015 Membro '%s' exige uma instância. Instancie a classe antes de acessar campos e métodos de instância.
E3016 A função '%s' espera entre %s e %s argumentos; recebeu %s. Respeite argumentos obrigatórios, opcionais e variáveis da função ou método.
E3017 %s O destino precisa ser modificável; funções, constantes e o receptor isto não podem ser reatribuídos.
E3101 Divisão ou módulo por zero demonstrável em compilação. O denominador é uma expressão constante igual a zero.
E3102 Resultado inteiro fora do intervalo de 64 bits. Altere o cálculo ou use valores reais quando apropriado.
E3103 Índice constante inválido: %s. Índices negativos são aceitos dentro dos limites da coleção.
E3104 Incompatibilidade de tipo demonstrável: esperado '%s', recebido '%s'. Contratos explícitos não são removidos pela otimização.
E3105 Operação demonstravelmente inválida: %s. Use os tipos e limites aceitos pelo runtime.
E3106 Conversão literal inválida para '%s'. Valide o texto de entrada ou trate dados recebidos em execução.
E3107 Deslocamento constante fora do intervalo [0, 63]. A quantidade de bits precisa estar dentro dos limites de 64 bits.
E3108 O passo constante de uma fatia não pode ser zero. Use um passo positivo ou negativo diferente de zero.
E3201 Função pura depende do estado externo '%s'. Passe o valor por parâmetro; a CTFE não lê nem modifica variáveis externas à função.
E4001 A captura foi bloqueada; passe o valor como parâmetro explícito. Capturas de ambiente são excluídas deliberadamente do perfil compilado.
E4002 Importe um módulo fonte .delegua. Importação de código nativo ou carregado dinamicamente é excluída.
E9001 %s Verifique arquivos, opções, dependências e a toolchain configurada.
H0001 %s Informação complementar de um diagnóstico.
H3001 Você quis dizer '%s'? Sugestão determinística de nome visível no escopo.
R0001 %s Falha dinâmica do runtime; consulte a operação e a localização informadas. Tipos dinâmicos, aliases e entrada externa continuam validados em execução.
W0001 %s Aviso legado; consulte a mensagem e a posição.
W3001 Código inalcançável após transferência de controle. Remova ou reorganize a cauda que não executa.
W3002 Função com retorno tipado pode terminar sem retornar valor; o retorno implícito é nulo. Garanta um retorno nos caminhos relevantes.
W4001 Captura externa de '%s' detectada: exigiria upvalues, recurso desabilitado por segurança. Passe estado por parâmetros ou receptor explícito.
W4002 Carregamento dinâmico/NPM/FFI não é suportado por segurança. Use fontes .delegua conhecidas na compilação.

O parser recupera erros independentes. A verificação estática antecipa divisão por zero, overflow, índices e contratos literais. Em regiões com pegue, falhas conhecidas geram avisos W31xx e continuam tratáveis. Dados dinâmicos, aliases e retornos de funções ainda exigem validação em execução. Diagnósticos legados usam E0001/W0001/H0001; LSP e fix-its não existem.

Fora do perfil

Exclusões de segurança

Upvalues/capturas de estado externo, ponteiros crus, eval, carregamento dinâmico e NPM não são expostos. Esses exemplos devem falhar e fazem parte dos testes.

Capturas e execução dinâmica

Capturas/upvalues, eval, NPM, importação dinâmica e ponteiros crus não fazem parte do perfil. Uma função anônima sem captura é válida; uma função que usa estado da função externa recebe aviso e erro. Não substitua isso por uma closure silenciosamente incompleta.

FFI é uma fronteira explícita

A exclusão anterior de FFI foi revogada pelo usuário para assinaturas declaradas. ABI C e ABI gerenciada têm contratos próprios. Isso permite bibliotecas nativas confiáveis e não concede isolamento ao código C. Compatibilidade JavaScript, dialetos e herança de interfaces têm exclusão definitiva no capítulo de decisões.

seguranca/01_captura_local.delegua

Abrir fonte e contrato de teste

funcao criar(x) {
    retorna funcao() {
        retorna x
    }

    // Captura implícita proibida.
}
seguranca/02_captura_global.delegua

Abrir fonte e contrato de teste

var externo: inteiro = 1
funcao obter() {
    retorna externo
}
seguranca/03_ffi.delegua

Abrir fonte e contrato de teste

// Uma classe estrangeira sem assinatura/biblioteca explícita é inválida.
classe estrangeira Biblioteca {
}
seguranca/04_importacao_dinamica.delegua

Abrir fonte e contrato de teste

var caminho: texto = "modulo.delegua"
var modulo: qualquer = importar(caminho)

Uma função que retorna outra função sem captura é válida. Receptor explícito de método ligado é suportado. Ausência de implementação não é motivo para chamar um recurso de inseguro.

Com limites

Plataformas e limites da implementação

Linux x86_64 é a plataforma validada com DMD e LDC2, Clang e GCC. A CLI permite configurar target, sysroot, compilador e runtime separadamente para preparar builds cruzados.

Alvo validado e configuração

Linux x86_64 é a plataforma coberta pelos testes. --cc, --target, --sysroot, --runtime-object, --runtime-root, --pkg-config, --cflag e --ldflag separam compilador C, alvo e dependências. Um runtime construído para o mesmo alvo é obrigatório. Não se anuncia Windows/macOS ou cross apenas porque uma opção foi aceita.

Por que não múltiplos backends/dialetos?

O foco é uma linguagem com contratos consistentes, saída C99 e toolchains externas conhecidas. Não há backend próprio LLVM/assembly ou emulação de dialetos. Projetar limites claros reduz combinações de semântica que não poderiam ser validadas de forma confiável.

Windows/macOS e executáveis cruzados ainda não foram validados. Instaladores são shell/Linux. Não há bigint, dialetos extras, threads da linguagem, debugger ou bibliotecas Node. Consulte o guia de desenvolvimento para configurar a toolchain.

Com limites

JSON, rede, arquivos e coleções do CGD

Namespaces cgd:json, cgd:rede, cgd:arquivos, cgd:colecoes, cgd:matematica, cgd:textos, cgd:estatistica e cgd:caminhos fornecem classes de biblioteca. cgd:nativo é a ponte de implementação.

Escolher uma biblioteca

Recurso Contrato
cgd:json JSON.deTexto, analisar/serializar, obter/contem/caminho/definir/copiar/chaves. Profundidade, nós, Unicode, números grandes e ciclos têm contratos explícitos.
cgd:rede Sessao de libcurl; ClienteHTTP e RespostaHTTP com obter/enviar/enviarJSON/atualizar/remover. Rede só acontece quando o programa pede.
cgd:arquivos Arquivo(caminho): ler/linhas/escrever/anexar/informacoes/tamanho/remover. Cada chamada fecha seu descritor; leitura padrão 16 MiB, teto 64 MiB.
cgd:matematica Matematica sobre libm: seno/cosseno/tangente/raizQuadrada/potencia/absoluto/piso/teto/logaritmo/exponencial.
cgd:colecoes Colecoes.unicos/intervalo/reduzir/agrupar/achatar. Callbacks não capturam ambiente.
cgd:nativo Primitivas da ABI gerenciada para implementar bibliotecas; prefira as classes públicas acima nos programas.

I/O e respostas com erros

Arquivo preserva bytes, inclusive zero interno; operações Unicode ainda exigem UTF-8 válido. Escrita pode ser parcial se o sistema falhar: não é transação. ClienteHTTP usa sessão isolada por requisição; sucesso exige transporte sem erro e status 200..299. exigirSucesso transforma uma resposta inspecionável em exceção tratável. Nunca há rede automática no editor.

bibliotecas/json_classe.delegua

Abrir fonte e contrato de teste

var biblioteca: qualquer = importar("../../bibliotecas/json.delegua")
var dados: qualquer = biblioteca.JSON.analisar('{"nome":"CGD","versao":1}')

escreva(biblioteca.JSON.serializar(dados))

var documento: qualquer = biblioteca.JSON(dados)
escreva(documento.obter("nome"))
escreva(documento.definir("versao", 2).texto())
bibliotecas/rede.delegua

Abrir fonte e contrato de teste

// Não faz requisições externas: introspecção e codificação são locais.
var rede: qualquer = importar("../../bibliotecas/rede.delegua")
escreva(rede.escapar("a b/c"))
escreva(rede.decodificar("a%20b%2Fc"))
escreva(tamanho(rede.opcoes()) > 100)
bibliotecas/colecoes.delegua

Abrir fonte e contrato de teste

var biblioteca = importar("../../bibliotecas/colecoes.delegua")
escreva(biblioteca.Colecoes.unicos([1, 2, 1, 3, 2]))
escreva(biblioteca.Colecoes.intervalo(5, 0, - 2))
bibliotecas/json_navegacao.delegua

Abrir fonte e contrato de teste

var json: qualquer = importar("cgd:json")
var documento: qualquer = json.JSON.deTexto('{"pessoa":{"nome":"Ana"},"valor":null}')
escreva(documento.caminho(["pessoa", "nome"]))
escreva(documento.obter("ausente", 7))
escreva(documento.obter("valor", 7))
var copia: qualquer = documento.copiar()
copia.definir("novo", verdadeiro)
escreva(documento.contem("novo"))
bibliotecas/arquivos.delegua

Abrir fonte e contrato de teste

var arquivos: qualquer = importar("cgd:arquivos")
var arquivo: qualquer = arquivos.Arquivo("dados.txt")
// Instanciar não abre nem modifica o arquivo. I/O só acontece por chamada explícita.
escreva(arquivo.caminho())

JSON em Delégua puro, limite de profundidade e preservação de números além da representação nativa. Rede exige libcurl >=7.86; opções com ponteiros/callbacks arbitrários são recusadas. WebSocket depende da libcurl instalada, não validado neste ambiente. I/O usa arquivos regulares, fecha descritores por chamada e limita leituras/escritas a 64 MiB.

Com limites

Métodos estáticos e ferramentas do editor

estatico declara método sem isto, herdado e acessível pela classe ou instância. O LSP local oferece completion por tipo, signature help e formatador com quatro espaços. Ctrl+Shift+I formata no VS Code; --formatar formata pela CLI. Construtor/destrutor/estatico são palavras-chave. Hover oferece prévia CTFE limitada para expressões constantes e chamadas puras, sem compilar por edição.

Receptor e visibilidade

estatico/estático declara método sem isto. Ele pode ser herdado e acessado pela classe ou por instância. Campos estáticos não são suportados. Membros públicos/protegidos/privados conservam visibilidade no frontend e no runtime; um privado derivado oculta o homônimo herdado, sem vazar a sugestão pública antiga.

classe Fabrica {
    estatico resposta(): inteiro { retorna 42 }
}
escreva(Fabrica.resposta())

Editor como consumidor do frontend

O LSP usa a mesma sequência de análise da CLI, mantém documentos em memória e respeita revisões. Navegação, completion, tipos, formatação e diagnósticos não fazem build por edição. Receptores desconhecidos não recebem sugestões de outros escopos. Resultado CTFE é uma informação limitada de hover, não execução ou depuração do programa.

estaticos.delegua

Abrir fonte e contrato de teste

classe Calculadora {
    estatico dobro(valor: inteiro): inteiro {
        retorna valor * 2
    }
}

classe Avancada herda Calculadora {
}

escreva(Calculadora.dobro(3))
escreva(Avancada.dobro(4))
var calculadora: Calculadora = Calculadora()
escreva(calculadora.dobro(5))

Campos estáticos e depurador/DAP não estão implementados. O editor analisa sem compilar/linkar por edição. Literais longos não são divididos pelo formatador. A prévia usa cópias e orçamento por revisão; falhas deixam o valor para execução.

Com limites

Contratos, arrows e FFI C

Classes abstratas, interfaces explícitas, enums numéricos e arrow functions sem captura. Classes estrangeiras usam @definicao com ABI C escalar ou gerenciada.

Contratos explícitos

Interfaces descrevem campos e métodos públicos; classes usam implementa para satisfazer o contrato, inclusive com membros herdados. Implementações mantêm assinatura explícita. Classe abstrata não pode ser instanciada e pode declarar métodos abstratos. Não há herança entre interfaces: foi excluída por decisão de escopo, não adiada.

interface Nomeavel { nome(): texto; }
classe Pessoa implementa Nomeavel {
    nome(): texto { retorna "Ana" }
}
enum Estado { Inicial, Final = 7 }

Enums e arrows

Enum é um namespace congelado de inteiros com incremento implícito e diagnóstico de duplicatas/overflow. Seu nome como tipo é alias de inteiro; não há enum nominal ou união algébrica. Arrows reutilizam funções anônimas sem captura. São escolhas do perfil CGD, não uma declaração de equivalência com todos os ambientes Delégua.

FFI e fronteira de confiança

@definicao declara biblioteca, prefixo e símbolo; a ABI C escalar usa numero/real como double, inteiro/longo como int64_t, logico como bool e texto como const char*. Não presuma int C de 32 bits quando o contrato diz inteiro de 64 bits. Textos com zero interno são recusados nessa ABI. A ABI gerenciada delegua passa delegua_value e valida contratos. Assinaturas erradas e código nativo podem corromper o processo: FFI não é sandbox. Callbacks/structs/variádicos arbitrários não são representados por conversões presumidas.

Enums em escopos locais e classes

Enums são açúcar para constantes inteiras agrupadas num namespace imutável. Podem ser declarados em módulos, funções, métodos, blocos de controle, callbacks e corpos de classe/interface; não exigem um contexto global. O alias numérico tem escopo lexical e não vaza ao sair do bloco. Nomes locais podem reaparecer em blocos independentes.

Dentro de classes, Classe.Enum e isto.Enum acessam o mesmo namespace, inclusive por herança, respeitando privado/protegido. O enum não ocupa um campo de cada instância nem habilita campos estáticos mutáveis. Dentro do corpo da classe o nome serve como alias inteiro; fora dele, anote valores como inteiro. Interfaces podem conter constantes sem exigir sua redeclaração na implementação.

Acesso conhecido a um membro resolve para o inteiro, inclusive em funções sem captura e em CTFE. Capturar um namespace local inteiro como valor continua sujeito às regras de captura; CTFE representa os membros escalares, não mapas. Receptores com efeitos, como criar().Estado.Fim, continuam sendo avaliados uma vez. Os enums continuam numéricos, sem identidade nominal ou restrição aos membros declarados.

funcao estado(): inteiro {
    enum Estado { Inicio, Final=7 }
    var atual: Estado = Estado.Final
    retorna atual
}
classe Maquina {
    enum Estado { Inicio, Final=4 }
    atual: Estado = isto.Estado.Final
}
escreva(Maquina.Estado.Final)
linguagem/38_contratos.delegua

Abrir fonte e contrato de teste

interface Medida {
    valor(): inteiro;
}

classe abstrata Base {
    abstrato

    valor(): inteiro;
}

classe Concreta herda Base implementa Medida {
    valor(): inteiro {
        retorna 5
    }
}

enum Estado {
    Inicial, Final = 7
}

var objeto: Medida = Concreta()
var duplicar: funcao =(valor: inteiro): inteiro => valor * 2
escreva(objeto.valor())
escreva(Estado.Final)
escreva(duplicar(3))
bibliotecas/matematica.delegua

Abrir fonte e contrato de teste

var biblioteca: qualquer = importar("cgd:matematica")
escreva(biblioteca.Matematica.cosseno(0))
escreva(biblioteca.Matematica.raizQuadrada(9))
linguagem/40_enums_escopos.delegua

Abrir fonte e contrato de teste

funcao estado(): inteiro {
    enum Estado {
        Inicio, Final = 7
    }

    var atual: Estado = Estado.Final
    retorna atual
}

classe Maquina {
    enum Estado {
        Inicio, Final = 4
    }

    atual: Estado = isto.Estado.Final
}

var vetor: funcao =(x: inteiro) => [x, x + 1]
escreva(estado())
escreva(Maquina.Estado.Final)
escreva(vetor(2))

Enums são namespaces congelados e alias inteiro; interfaces exigem assinaturas explícitas. FFI exige código nativo confiável. Composição mescla permanece fora desta versão; integração JS é excluída; consulte docs/evolucao-linguagem.md.

Com limites

Decisões de escopo: o que não fará parte da linguagem

O CGD é uma linguagem compilada para C99 com referência em Delégua. Estas decisões são parte de seu contrato, não promessas para uma versão futura.

Exclusões definitivas

Recurso Contrato
Compatibilidade com JavaScript e classes de host JS Não será implementada. Evita depender de VM, coerções e ciclo de vida de um ambiente JavaScript. FFI C tipada é a integração nativa.
Múltiplos dialetos Não serão implementados. Há uma gramática e um conjunto de contratos a manter, testar e documentar.
Herança de interfaces Não será implementada. Classes podem implementar vários contratos diretamente; não há grafo de interfaces herdadas para resolver.
NPM, eval e importação dinâmica Não fazem parte do perfil. Módulos fonte são conhecidos na compilação, e código do programa não é executado pela edição.

Limitação não é sinônimo de insegurança

Composição mescla, enums nominais, campos estáticos e ABIs C compostas não estão disponíveis. Isso não é uma classificação automática de insegurança e não constitui compromisso de implementação. DAP continua adiado; executar não é depurar. Outros alvos precisam de toolchain e runtime validados antes de serem anunciados.

Origem e autoria

Delégua original é um projeto da Design Líquido. O CGD preserva as referências e a licença Apache-2.0; sua documentação explica o perfil próprio em vez de sugerir compatibilidade total com o interpretador, Node ou JavaScript.

Disponível

Erros do programa: apresentação e localização

Falhas não capturadas usam a mesma estrutura visual dos diagnósticos do compilador, sem formatação adicional no caminho de sucesso.

Ler um diagnóstico

O cabeçalho identifica a categoria, seguido por arquivo, linha e coluna. Quando o fonte está acessível, a linha e um marcador ^ mostram a operação falível. Tabs são expandidas; o arquivo é tratado como texto UTF-8 e controles são escapados para não inserir sequências de terminal.

error[R0001]: Divisão por zero.
 --> { programa.delegua:2:10 }
   2 | retorna a / b
     |          ^

Custo e limites

O C gerado mantém descritores estáticos e atribui um ponteiro antes de operações que podem falhar. Não há leitura de arquivo ou formatação por nó no caminho normal. Somente uma exceção sem tratador é renderizada; pegue continua recebendo o valor sem impressão automática. A API C antiga de localização é preservada.

A linha é lida do disco na falha, não embutida no executável. Se o arquivo mudou, o trecho pode divergir do fonte compilado. Fonte ausente, inválido, muito longo ou fora do orçamento nunca apaga o código e a localização conhecidos. A leitura é limitada e só aceita arquivo regular; FIFO/dispositivo não bloqueia o diagnóstico. A janela mostrada é limitada e pode indicar posição fora do trecho.

O código dinâmico permanece R0001. O formato humano não substitui um protocolo de depuração.

Disponível

Biblioteca padrão: textos, estatística, caminhos e coleções

Classes próprias agrupam operações úteis, com tipos explícitos, limites e comportamento definido para entradas vazias. As importações são estáticas e nenhum método é executado pelo editor.

Textos — cgd:textos

Textos.comecaCom/terminaCom aceitam prefixo/sufixo vazio. repetir exige quantidade entre 0 e 1.000.000 e resultado de até um milhão de pontos de código. preencherInicio/preencherFim exigem exatamente um caractere Unicode de preenchimento; não truncam texto maior que o comprimento pedido.

linhas normaliza CRLF e CR e preserva linhas vazias e a quebra final. digitos aceita somente uma sequência não vazia de dígitos ASCII. juntar combina texto[]; inverter inverte pontos de código, não grafemas; contar conta ocorrências não sobrepostas e rejeita trecho vazio.

var textos: qualquer = importar("cgd:textos").Textos
escreva(textos.preencherInicio("7", 3, "0"))
escreva(textos.digitos("0123"))

Estatistica — cgd:estatistica

Estatistica oferece soma, media, minimo, maximo, mediana, variancia, desvioPadrao e resumo. soma([]) é zero; média, mínimo, máximo e mediana rejeitam vazio. Mediana ordena uma cópia e preserva o vetor recebido.

Variância usa atualização incremental, exige um elemento na versão populacional e dois na amostral. O segundo argumento amostral é falso por padrão. Não há arredondamento decimal implícito; cálculos usam números do runtime. resumo reúne quantidade, soma, mínimo, máximo, média, mediana e variância.

var estatistica: qualquer = importar("cgd:estatistica").Estatistica
escreva(estatistica.mediana([4, 1, 2, 3]))
escreva(estatistica.variancia([1, 2, 3], verdadeiro))

Caminhos — cgd:caminhos

Caminhos.absoluto consulta o prefixo /. normalizar remove componentes vazios e ., resolve .. lexicalmente e preserva .. que não podem ser resolvidos em caminho relativo. Vazio vira .; não se sobe acima de /.

juntar recebe texto[]; um componente absoluto reinicia o caminho acumulado. nome, diretorio, extensao e semExtensao operam no caminho normalizado. A extensão inclui o ponto; .perfil não possui extensão. Nenhuma operação consulta disco, resolve symlinks, cria diretórios ou garante confinamento: normalização lexical não é uma sandbox.

var caminhos: qualquer = importar("cgd:caminhos").Caminhos
escreva(caminhos.juntar(["dados", "..", "saida", "a.json"]))
escreva(caminhos.extensao("a.tar.gz"))

Colecoes — resultados e compartilhamento

Além de unicos/intervalo/reduzir/agrupar/achatar, a classe oferece primeiro/ultimo com alternativa para vazio, encontrar com predicado, contar, particionar, combinar, blocos e frequencias. particionar devolve tupla (aceitos, recusados). combinar para no menor vetor. blocos exige tamanho positivo e conserva o último bloco incompleto.

Os resultados são coleções novas, mas seus elementos são referências rasas aos dados de entrada. frequencias e agrupar exigem chaves aceitas pelo dicionário. Callbacks são avaliados em ordem e não podem capturar ambiente; seus efeitos e exceções permanecem observáveis.

intervalo é semiaberto, recusa passo zero e limita o resultado a um milhão de elementos. Se o próximo passo sair de int64, a iteração termina: esse valor já ultrapassou qualquer limite final representável, sem provocar overflow artificial.

Arquivos e matemática

Arquivo.lerJSON combina leitura limitada e parser JSON; escreverJSON serializa antes de abrir o destino. copiarPara lê antes de escrever, inclusive se origem e destino coincidirem. Não é uma cópia em streaming nem uma transação; respeita o limite de leitura.

Matematica acrescenta arcoSeno/arcoCosseno/arcoTangente/arcoTangente2, logaritmo10/logaritmo2, arredondar, truncar, hipotenusa e resto. arredondar segue round de C (metades para longe de zero); resto usa fmod, distinto do operador inteiro %. A ABI permanece explícita e validada.

APIs matemáticas seguem libm: domínios inválidos podem produzir valores não finitos. Caminhos são POSIX lexicais, sem resolução de links.