O que é o Syntella

O Syntella é uma linguagem de programação pequena e de uso geral, construída em torno de uma única ideia: um programa deve comportar-se exatamente como se lê. Nada é forçado, nada salta, nada acontece fora da página.

É verificada estaticamente. O mesmo código-fonte corre de duas formas: um interpretador que percorre a árvore, escrito em Rust, executa-o diretamente enquanto desenvolve, e um backend LLVM compila-o para um binário nativo autónomo quando o publica. Não há VM nem runtime para instalar na máquina que corre o resultado.

use io

type Point {
    x: int
    y: int
}

impl Point {
    func manhattan(): int { self.x + self.y }
}

func main() {
    let p: Point = Point(3, 4)
    io.println(str(p.manhattan()))   // 7
}

A ideia: sem surpresas

A maioria das linguagens acumula conveniências que alteram discretamente o significado do seu código. O Syntella remove-as de propósito, e todo o desenho decorre dessa única decisão.

• Sem coerção implícita. Um int nunca é promovido silenciosamente para float. Com anotações de tipo, int + float é um erro de compilação, não uma conversão oculta. Converte de propósito ou não converte de todo.
• Sem valores de verdade implícitos. Uma condição é um bool. Um int ou uma string não são uma condição, por isso if count { ... } não existe. Escreve a comparação que pretende.
• Sem fluxo de controlo oculto. Não há exceções que se propaguem através das molduras de chamada. Uma função que pode falhar devolve a falha como um valor, e propaga-a com um ? visível. Ao ler um programa, consegue ver todos os pontos onde o controlo pode sair de uma função.
• Sem pontos e vírgulas. As instruções terminam na próxima palavra-chave, chaveta ou fim de ficheiro. Não há nada para esquecer nem nada para inserir.
• Uma única forma de iterar com um bloco. Em vez de iteradores, geradores e sintaxe de blocos ao mesmo tempo, há uma primitiva, flow com yield, e consegue ver o ciclo que ela conduz.

O ganho é que ler Syntella é suficiente. Não precisa de conhecer uma tabela de regras implícitas para prever o que uma linha faz.

Uma amostra mais completa

Eis um programa que usa em conjunto um flow personalizado, defer e concorrência leve:

use io

// A flow runs the caller's block at each yield.
flow times(n) {
    for i in range(n) {
        yield
    }
}

func main() {
    defer io.println("done")

    let results = chan(3)
    let i = 0
    while i < 3 {
        spawn { results <- i * i }
        i = i + 1
    }

    times 3 {
        io.println(str(<-results))
    }
}

O spawn inicia três tarefas que enviam para um canal, times 3 { ... } corre o bloco três vezes para as receber, e defer imprime done à saída. Cada um desses comportamentos está escrito no ponto onde acontece.

Duas formas de correr o mesmo código

	syt run	syt build
Backend	Interpretador que percorre a árvore (Rust)	Binário nativo LLVM
Arranque	Instantâneo	Microssegundos, sem runtime
Cobertura	Toda a linguagem	Quase toda a linguagem
Utilize para	Iterar, scripts, testes	Publicar uma CLI ou serviço

Desenvolve com run e publica com build. A linguagem não muda entre os dois; apenas muda a forma como é executada. Veja Binários nativos.

De onde vem

O Syntella é uma mistura deliberada, não um clone de nenhuma linguagem em particular:

• Do Go: func, defer, e concorrência CSP (chan, spawn, select), além da ideia de que uma linguagem pequena com uma toolchain completa é uma vantagem.
• Do Rust: let e const, type com impl e contract, use, verificação estática, e erros como valores comuns propagados com um ? final.
• Do Ruby: os blocos, reformulados na primitiva explícita flow e yield.

A tese que assenta sobre tudo isto é a explicitude. Onde essas linguagens mantêm uma conveniência que oculta comportamento, o Syntella abandona-a.

Para que serve

O Syntella é dirigido ao trabalho quotidiano de backend e de ferramentas. Tem um servidor HTTP na biblioteca padrão, um gestor de pacotes, um formatador e um servidor de linguagem, tudo dentro do único binário syt. Como pode compilar para um executável pequeno, rápido e sem dependências, adequa-se a ferramentas de linha de comandos e serviços que queira entregar a alguém como um único ficheiro.

Estado honesto

O Syntella é jovem. As fundações são sólidas: um pipeline completo (lexer, parser, análise semântica, verificação de tipos), um interpretador que percorre a árvore com concorrência completa ao estilo Go, tratamento de erros tipado sem exceções, genéricos estritos, um motor de expressões regulares nativo, um gestor de pacotes, um servidor de linguagem, um formatador e compilação nativa através de LLVM. Segundo o próprio STATUS do projeto, está a cerca de 80% do caminho para uma linguagem de uso geral pronta para produção: o que falta é volume, não o desenho central.

Como ler esta documentação

O guia é um percurso pela linguagem, um conceito de cada vez, por ordem. Comece em Instalação, ou salte para um capítulo:

• Valores e tipos e Variáveis e operadores
• Fluxo de controlo, Funções, e flow e yield
• Tipos e contratos, Genéricos, e Tratamento de erros
• Concorrência e Módulos e pacotes

A referência cobre a CLI e a biblioteca padrão.