Tutorial da linguagem de programação Glide

Cinco aulas.
A linguagem inteira
na sua cabeça.

Aprenda a linguagem de programação Glide por Murillo Deolino em cinco aulas rápidas. Hello world, erros como valores, canais, um servidor HTTP e uma macro — todos os exemplos abaixo compilam com glide run.

Começar o tour Tutorial completo no GitHub →

1 · hello

Hello, world

fn main() -> int é o ponto de entrada. println! escreve na stdout com uma nova linha ao final; o ponto de exclamação indica que é uma macro. O valor de retorno é o código de saída do processo.

Salve o trecho como hello.glide e execute com glide run hello.glide.

hello.glide

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

2 · errors

Erros como valores

!T significa "ou um T ou um erro". ok(v) e err("msg") os constroem. O operador pós-fixo ? propaga: se o resultado for um erro, a função retorna imediatamente; caso contrário, v é desempacotado na variável local.

Sem exceções, sem tratadores de pânico — o modo de falha está na assinatura do tipo.

errors.glide

fn parse(n: int) -> !int {
    if n < 0 { return err("negative"); }
    return ok(n * 2);
}

fn pipeline(n: int) -> !int {
    let v: int = parse(n)?;
    return ok(v + 1);
}

fn main() -> int {
    let r: !int = pipeline(10);
    if r.ok { println!("got:", r.val); }
    else   { println!("err:", r.err); }
    return 0;
}

3 · channels

Canais e spawn

spawn inicia uma corrotina M:N. chan<T> é um canal tipado; make_chan(cap) cria um com buffer. Canais são valores de primeira classe — passe-os como argumentos, armazene em structs, feche-os com .close().

Para threads de SO em vez de corrotinas, use spawn_thread — mesma sintaxe, agendador diferente.

channels.glide

fn producer(c: chan<int>) {
    for i in 0..3 { c.send(i * i); }
    c.close();
}

fn main() -> int {
    let c: chan<int> = make_chan(2);
    spawn producer(c);
    while let v = c.recv() { println!("got:", v); }
    return 0;
}

4 · http

Um servidor HTTP

Importe stdlib::http::*. Um handler é fn(*HttpRequest) -> HttpResponse. http_listen(port, handler) faz o bind, aceita conexões e mantém o loop eternamente.

Para TLS, troque por https_listen(port, cert, key, handler) — mesma estrutura, mais os arquivos PEM. Roteadores, middlewares e servir arquivos estáticos estão em stdlib::http::router.

server.glide

import stdlib::http::*;

fn root(req: *HttpRequest) -> HttpResponse {
    if req.path.eq("/health") {
        return HttpResponse::ok().text("ok");
    }
    return HttpResponse::ok().html("<h1>hello from glide</h1>");
}

fn main() -> int {
    http_listen(8080, root);
    return 0;
}

5 · macros

Macros declarativas

macro_rules! combina padrões de tokens — $x:expr, $x:ident, $x:ty — e expande para código em tempo de compilação. A forma variádica $($x:expr),* combina uma lista separada por vírgulas e permite iterar sobre as capturas com $( … )*.

Para metaprogramação mais avançada, @derive(Name) e @name!(args) são macros procedurais que rodam dentro do compilador.

macros.glide

macro_rules! sum {
    ($($x:expr),*) => { {
        let mut t: int = 0;
        $( t = t + $x; )*
        t
    } };
}

fn main() -> int {
    let total: int = sum!(1, 2, 3, 4);
    println!("sum =", total);   // 10
    return 0;
}

O que vem a seguir

Cinco aulas concluídas; você viu a maior parte da linguagem. Escolha o que precisar.

Mais exemplos

Programas maiores — roteadores HTTP, JSON, percurso de arquivos, WebSockets, asm inline.

Ver exemplos →

Referência da Stdlib

Todos os itens pub da biblioteca padrão — um capítulo por módulo no livro.

Abrir a stdlib →

Cinco aulas. A linguagem inteira na sua cabeça.