Primeiros passos

Glide é uma linguagem de sistemas compacta: ela compila para um binário real que você pode enviar a um servidor sem precisar ter o Glide instalado. Se você já usou Python ou JavaScript, vai notar uma diferença importante: não há nenhum interpretador acompanhando o seu código enquanto ele roda. O programa é traduzido para instruções de máquina uma única vez (chamamos isso de compilar), e são essas instruções que de fato executam. É por isso que programas em Glide podem ser pequenos, rápidos, e não precisam de nada extra instalado para rodar.

O toolchain é um único binário (glide) e os projetos são descritos por uma única struct em um arquivo chamado glide.glide. É basicamente isso em termos de infraestrutura — em dois minutos estaremos escrevendo código.

Instalação

No macOS e no Linux, cole isso no seu terminal:

curl -fsSL https://glide-lang.org/install.sh | bash

No Windows, abra o PowerShell e cole isso:

iwr -useb https://glide-lang.org/install.ps1 | iex

O instalador coloca um único executável em ~/.glide/bin/glide e imprime a linha que você precisa adicionar ao PATH do seu shell. Reinicie o terminal e então verifique:

glide version

Você deve ver glide 0.3.3 ou mais recente.

Seu primeiro programa

Crie um arquivo chamado hello.glide com este conteúdo:

fn main() -> i32 {
    println!("hello, glide");
    return 0;
}

Agora rode-o:

glide run hello.glide

Você deve ver hello, glide impresso. É isso — você escreveu, compilou e executou um programa em Glide.

Vamos olhar para as quatro partes desse trecho, porque todas elas carregam significado que você verá em todo arquivo Glide:

• `fn main()` — fn declara uma função. main é o nome que o toolchain procura quando você roda um programa: é o ponto de entrada, o lugar onde a execução começa.
• `-> i32` — a função retorna um valor do tipo i32 (um inteiro de 32 bits). No caso de main, o valor de retorno se torna o código de saída do programa: 0 significa sucesso, qualquer outro valor significa falha. (Experimente return 1; e rode o arquivo novamente — o glide run vai sair com um status diferente de zero.)
• `println!(...)` — println! escreve uma linha no stdout. O ! no final faz parte do nome; ele indica que isso é uma macro (um recurso que faz manipulação de texto em tempo de compilação). Por enquanto, trate-o como "a função de imprimir."
• `return 0;` — toda instrução termina com ;. O return é obrigatório — Glide não infere um valor de retorno a partir da última expressão como algumas linguagens fazem.

Um projeto de verdade

Um único arquivo é suficiente para um script, mas quando você passar de cem linhas vai querer um projeto. O glide new cria um pra você:

glide new hello
cd hello

Isso cria a seguinte estrutura:

hello/
  glide.glide        o manifesto — nome, versão, deps, alvo de build
  src/
    main.glide       fn main() fica aqui
  .gitignore

Agora abra o glide.glide. Não é um arquivo de configuração YAML ou JSON — é código-fonte Glide, declarando uma variável chamada manifest do tipo Package:

let manifest: Package = Package {
    name:        "hello",
    version:     "0.1.0",
    description: "",
    author:      "",
    license:     "",
    repository:  "",
    bin:         "src/main.glide",
    deps: vec_of(
    ),
};

A CLI nunca compila esse arquivo — ela lê os campos literais que estão nele. O motivo de ele ainda usar sintaxe Glide (em vez de YAML) é que você pode editá-lo com todas as suas ferramentas normais (completação via LSP, destaque de sintaxe, etc.) e a estrutura é a mesma de todo o resto da linguagem.

De dentro do diretório do projeto, os comandos não precisam de um argumento de arquivo — eles buscam bin: "src/main.glide" no manifesto:

glide run       # compila + roda src/main.glide
glide build     # compila para ./build/hello.exe (ou ./build/hello no Linux/macOS)
glide check     # faz verificação de tipos sem compilar — retorno rápido para o seu editor

Os quatro comandos que você usará todo dia

Toda CLI tem dezenas de opções. Esses quatro cobrem a maior parte de um dia real escrevendo Glide:

• `glide run` — compila e executa. O padrão enquanto você escreve código. Passe um caminho de arquivo (glide run foo.glide) para casos avulsos, ou apenas glide run dentro de um projeto.
• `glide build` — compila e para. Use --release para o build otimizado que vai para produção. Use --target=x86_64-linux-gnu (ou aarch64-apple-darwin, ou x86_64-windows-gnu) para compilar cruzado para outro sistema operacional sem sair da sua máquina.
• `glide check` — somente verificação de tipos, sem geração de código de máquina. Usado por editores e CI. Rápido: consegue apontar uma incompatibilidade de tipos em milissegundos.
• `glide new <name>` — cria um projeto novo. Use glide new <name> --lib se você estiver começando uma biblioteca da qual outros vão depender.

Mais dois que você vai conhecer em Módulos e pacotes:

• `glide add <name> <github.com/user/repo> <rev>` — adiciona uma dependência externa ao glide.glide.
• `glide fetch` — baixa as dependências declaradas no manifesto para glide_modules/.

O que aconteceu por baixo dos panos

Quando você rodou glide run hello.glide, o toolchain passou por cinco etapas:

1. Parse — lê o texto e constrói uma árvore (uma AST) que representa a estrutura do programa.
2. Verificação de tipos — verifica se toda variável é usada no tipo em que foi declarada, se toda função recebe os tipos de argumento corretos e se todo valor vive tempo suficiente. É aqui que a maioria dos erros de iniciante é capturada — em tempo de compilação, antes de o programa executar.
3. Emissão de C — traduz a AST para código-fonte C.
4. Compilação do C — invoca o compilador C do sistema (cc, clang ou o zig cc embutido).
5. Execução — executa o binário resultante.

Você pode parar em qualquer etapa. glide check para após a etapa 2. glide build --emit-c mantém o C gerado em ./build/ caso você queira dar uma olhada. O binário final é apenas um executável nativo comum — empacote-o, envie-o, rode-o em um servidor sem o Glide instalado.

Para onde ir agora

Você tem um toolchain funcionando e um primeiro programa. O restante do livro constrói a linguagem a partir deste ponto:

• O próximo capítulo (Tipos e bindings) fala sobre os valores que você pode armazenar: inteiros e floats por largura, strings, structs, vetores, hashmaps. É onde você vai ver o sistema de tipos estático do Glide entrar em ação de verdade.
• Depois disso, Funções e fluxo de controle cobre if / match / for e como blocos retornam valores.