49 Exemplos Progressivos

Artcode usa let para bindings imutáveis e var para mutáveis. A inferência de tipos é automática — Int, Float, String e Bool são detectados pelo compilador sem anotação.

// Exemplo 01 - Valores e Variáveis
let inteiro  = 42;
let flutuante = 3.14;
let texto    = "Artcode";
let booleano = true;
println(inteiro);
println(flutuante);
println(texto);
println(booleano);
let soma = inteiro + 8;
println(soma);

Arrays em Artcode são dinâmicos e heterogêneos por padrão. O tipo Optional é expresso com none — um literal especial que garante ausência de valor sem recorrer a null ou ponteiros nulos.

// Exemplo 02 - Arrays e Option (None)
let nums  = [1, 2, 3];
let vazio = [];
let opt   = none; // literal option vazio
println(nums);
println(vazio);
println(opt);

Artcode usa if/else clássico, mas os operadores lógicos são palavras-chave: and, or, !. Escopos aninhados com { } criam novos namespaces — variáveis locais não "vazam" para o escopo externo (shadowing controlado).

// Exemplo 03 - Controle de Fluxo
let a = 10; let b = 20;
if (a < b) { println("a < b"); } else { println("a >= b"); }
if (a < b and b > 15) { println("duas condições"); }
let sol = true;
if (sol) { println("Praia!"); }
if (!sol or a == 10) { println("Uma condição verdadeira"); }
// Escopo aninhado
let nivel = "global";
{ let nivel = "local"; println(nivel); }
println(nivel); // "global" — não foi afetado

Funções são declaradas com func e suportam anotações de tipo opcionais nos parâmetros e retorno. Closures capturam o ambiente léxico automaticamente — variáveis do escopo externo ficam acessíveis sem nenhuma sintaxe especial.

// Exemplo 04 - Funções e Captura de Escopo
func soma(a: Int, b: Int) -> Int { return a + b }
println(soma(2, 3));

let x = 5;
func inc(n) { return n + x } // captura `x` do escopo externo
println(inc(10)); // 15

struct define tipos produto com campos nomeados. enum define tipos soma com variantes que podem carregar dados. match faz pattern matching exaustivo — casos com .Variant desestrutura os dados da variante automaticamente.

// Exemplo 05 - Structs, Enums e Match
struct Pessoa { nome: String, idade: Int }
enum Status { Ok, Erro(String) }

let p = Pessoa { nome: "Ada", idade: 42 };
println(p.nome); println(p.idade);

let falha = Status.Erro("Falhou");
match falha {
    case .Ok:          println("Tudo certo")
    case .Erro(msg):   println(msg)
}

Variantes de enum podem ser referenciadas sem o prefixo do tipo quando o compilador consegue inferir o contexto — use .Variant em vez de Tipo.Variant. Para evitar ambiguidade, a forma qualificada (Resultado.Ok(10)) é sempre válida.

// Exemplo 06 - Enum Shorthand & Inferência
enum Resultado { Ok(Int), Err(String) }

let r1 = Resultado.Ok(10);
let r2 = Resultado.Err("Falha");

match r1 { case .Ok(v):  println(v)  case .Err(e): println(e) }
match r2 { case .Ok(v):  println(v)  case .Err(e): println(e) }

Cases de match aceitam um guard opcional com if para adicionar predicados extras sobre o valor desestruturado. Permite lógica condicional precisa sem aninhamento de ifs dentro dos arms.

// Exemplo 07 - Pattern Matching com Guards
enum E { V(Int), W(Int) }
let x = E.V(10);
let y = E.V(5);
let z = E.W(8);

match x {
    case .V(v) if v > 8: println(f"v>8: {v}")
    case .V(v):           println(f"v: {v}")
    case .W(w):           println(f"w: {w}")
}

f-strings em Artcode suportam especificadores de formato embutidos com : — como {n:hex}, {s:upper}, {s:trim}, {s:pad10}. Chaves literais são escapadas com {{ }}.

// Exemplo 08 - f-Strings e Especificadores de Formato
let n = 255;
let s = "  AbC  ";
println(f"hex={n:hex} trim={s:trim} upper={s:upper}");
println(f"lower={s:lower} pad={s:pad10}");
println(f"chave literal: {{ {n} }}");

Métodos são funções declaradas com func Tipo.nome(self). O self é auto-bound ao receiver na chamada. Enums têm acesso a variant e values intrinsecamente para inspeção em runtime.

// Exemplo 09 - Métodos em Structs e Enums
struct Pessoa { nome: String }
func Pessoa.greet(self) { println(f"Olá, {self.nome}!"); }

let p = Pessoa { nome: "Ada" };
p.greet(); // → Olá, Ada!

enum Status { Ok, Err(String) }
func Status.describe(self) {
    println(f"variant={variant} values={len(values)}");
}
let s1 = Status.Ok;
let s2 = Status.Err("x");
s1.describe(); s2.describe();

O enum Result (Ok, Err) está no prelude e é usado para propagação explícita de erros. Sem exceções implícitas — cada falha é um valor que o caller deve tratar com match.

// Exemplo 10 - Propagação explícita de Result
func divide(a: Int, b: Int) -> Result {
    if b == 0 { return Result.Err("/0") }
    return Result.Ok(a / b)
}
func quarter(n: Int) -> Result {
    let r = divide(n, 2);
    match r {
        case .Ok(h): {
            let r2 = divide(h, 2);
            match r2 {
                case .Ok(q):  return Result.Ok(q)
                case .Err(e): return Result.Err(e)
            }
        }
        case .Err(e): return Result.Err(e)
    }
}
let r = quarter(40);
match r { case .Ok(v): println(f"q={v}")  case .Err(e): println(e) }

Arrays têm métodos nativos como .sum(), .count(), .map(fn) e .filter(fn). O type-checker emite diagnósticos se você chamar sum() em um array heterogêneo.

// Exemplo 11 - Métodos builtin de Array
let nums = [1, 2, 3, 4];
println(nums.sum());   // 10
println(nums.count()); // 4

let mixed = [1, 2, "a"];
println(mixed.count()); // 3 (ok — heterogêneo)
// mixed.sum() → erro de tipo (array misto)

O runtime Artcode emite métricas de execução no stderr ao finalizar: contagem de erros tratados, crash_free%, chamadas de função etc. Este exemplo mostra como evitar divisão por zero e ainda observar as métricas.

// Exemplo 12 - Métricas de Execução (ver stderr)
println("A"); println("B");
let denom = 0;
if denom == 0 {
    println("denom is zero, skipping division")
} else {
    println(10 / denom)
}
println("C");
// → stderr: handled_errors=0  crash_free=100%

weak cria uma referência fraca — ela não impede o GC(ARC) de liberar o objeto. O operador w? é o upgrade opcional: retorna o valor se o dono ainda existir, ou None se já foi dropado.

// weak cria referência fraca para `a`
let a = 1;
let w = weak a;
// w? — upgrade opcional: retorna o valor se `a` existir
let opt = w?;

Stub mínimo usado pelo linter de dependências para detectar ciclos de referência potenciais. Cria uma referência weak "morta" — útil para verificar que o linter identifica o padrão sem precisar de um ciclo real.

// Nenhum ciclo real — weak "morta" simulada
let a = 1;
let w = weak a;
// sem API para drop programático ainda

on_finalize(obj, fn) registra uma função que será chamada quando o GC(ARC) liberar obj. Finalizers rodam de forma assíncrona e podem promover handles externos. Blocos performant usam a arena interna.

let outside = [99];

func fin_promote() {
    let _promoted = outside;
}

// Registra finalizer dentro de um bloco performant
performant {
    let _target = [1, 2, 3];
    on_finalize(_target, fin_promote);
}
// Ao sair do bloco, _target é finalizado e fin_promote é chamado

weak(obj) retorna um handle que não mantém o objeto vivo. unowned(obj) é um ponteiro direto sem ownership — válido enquanto o dono existir. weak_get(w) e unowned_get(u) são as APIs de depuração para obter o valor.

// Exemplo 1: weak — upgrade falha após drop do strong
{
    let owner = [99];
    let w = weak(owner);
    println("inside:", weak_get(w));
}
println("after block: owner foi dropado");

// Exemplo 2: unowned — válido enquanto dono existir
{
    let owner2 = [7];
    let u = unowned(owner2);
    println("inside:", unowned_get(u));
}
println("after block: owner2 foi dropado");

Blocos performant alocam objetos em uma arena de curta duração — o GC processa tudo de uma vez ao sair do bloco. Combinando com on_finalize, é possível observar e reagir ao ciclo de vida de objetos de curta duração com precisão.

let outside = [99];
let promoted = none;

func fin_promote() { let promoted = outside; }

performant {
    let _a = [1, 2, 3];
    on_finalize(_a, fin_promote);
}
// após блок: _a finalizado, fin_promote chamado

A stdlib embutida inclui: Map (map_new, map_set, map_get), Set, funções matemáticas (math_abs, math_pow, math_clamp), time_now, rand_next e I/O de arquivos (io_write_text, io_read_text).

// Map
let m = map_new();
map_set(m, "hello", 42);
println(map_get(m, "hello"));  // 42
println(len(m));               // 1

// Set
let s = set_new();
set_add(s, 10); set_add(s, 10); // duplicata ignorada
println(len(s)); // 1

// Math
println(math_pow(2, 3));    // 8
println(math_clamp(15, 1, 10)); // 10

// IO
io_write_text("out.txt", "Hello IO!");
println(io_read_text("out.txt"));

Blocos performant { } são uma funcionalidade experimental que contorna o GC padrão usando uma arena de memória. Objectos alocados dentro não podem vazar para fora — o type-checker rejeita return de valores da arena.

performant {
    let x = [1, 2, 3];
    // return x; ← rejeitado pelo TypeInfer (não pode vazar arena)
}

Artcode tem um modelo de atores baseado em mensagens. spawn actor { } cria um ator e retorna seu ID. actor_send(id, envelope(...)) envia mensagens. run_actors() aciona o scheduler cooperativo para processar a fila.

// Spawn do ator como expressão — retorna actor id
let a = spawn actor {
    let msg = actor_receive();
    if msg { println(msg); }
};

// Enviar envelopes para o ator `a`
let ok1 = actor_send(a, envelope(none, 7, 1));
let ok2 = actor_send(a, make_envelope(42, 5));

// Drive the scheduler — ator processa as mensagens
run_actors();

Demonstra uma carga CPU-bound com recursão para gerar chamadas quentes de função — útil para benchmarks de JIT/interpretador. A função sum_work usa tail-recursion e é chamada repetidamente para simular um microkernel de cálculo.

func sum_work(n) {
    func sum_down(i, acc) {
        if i <= 0 { return acc; }
        return sum_down(i - 1, acc + i);
    }
    return sum_down(n, 0);
}

func main() {
    // 200 chamadas de sum_work(20) para gerar hot calls
    sum_work(20); sum_work(20); sum_work(20);
    // ... (200 total)
    return 0;
}
main();

Código intencionalmente mal-formatado para testar o auto-formatter art fmt. Espaçamento inconsistente, chaves sem espaço — o formatter deve normalizar tudo enquanto preserva comentários e lógica.

// This file has terrible formatting!
let x= 10;
if x >5{
    println("Bigger!");
    // I want to keep this comment intact!
    if x>20 {
        println("Huge!");
    } else { println("Moderate"); }
}
// art fmt → normaliza espaçamento automaticamente

Demonstra três padrões que o linter art lint detecta: shadowing suspeito (reuso de nome de variável em escopo aninhado) e arms mortos em match (case após wildcard _ nunca será executado), além de hint de hotspot de alocação em loops fora de performant {}.

func test_shadowing() {
    let x = 10;
    if x > 5 {
        let x = 20; // ← linter: suspicious shadow
        println(x);
    }
}
func test_dead_arms() {
    let value = 5;
    match value {
        case _:  println("Caught all!");
        case 10: println("unreachable"); // ← dead code
    }
}
func test_memory_hotspot_hint() {
    for i in ([0, 1, 2]) {
        let pair = (i, [i, i + 1]); // ← allocation hotspot hint
    }
}
test_shadowing(); test_dead_arms(); test_memory_hotspot_hint();

Açúcar sintático avançado para monads nativas: if let Ok(v) = expr desestrutura inline; .is_ok(), .is_err(), .unwrap() e .unwrap_or(default) são métodos builtin de Result e Option.

func test_result_sugar() {
    let success = Result.Ok(42);
    let failure  = Result.Err("Went wrong");

    println(success.is_ok());        // true
    println(success.unwrap());       // 42
    println(failure.unwrap_or(-1)); // -1

    if let Ok(value) = success {
        println("Success:", value)
    }
    if let Err(msg) = failure {
        println("Failure:", msg)
    }
}

func test_option_sugar() {
    let some_val = Option.Some("Hello");
    let none_val = Option.None;

    println(some_val.is_some());              // true
    println(none_val.unwrap_or("Default"));  // "Default"

    if let Some(text) = some_val { println(text) }
}

test_result_sugar();
test_option_sugar();

Exemplo da trilha v0.2: combina while e for com tuples e destructuring em let, validando a evolucao do parser, runtime e inferencia de tipos para patterns compostos.

let pontos = [
    (1, 2),
    (3, 4),
    (5, 6),
];

                            let (x0, y0) = (100, 200);
                            println("tuple inicial:", x0, y0);

                            for ponto in (pontos) println(ponto);

let sempre_falso = false;
                            while (sempre_falso) println("nao executa");

Demonstra tratamento explicito de erros no runtime com try/catch. O primeiro bloco captura um TypeError e continua a execucao. O segundo bloco mostra o fluxo normal quando nao ha erro.

try {
    let (x, y) = 10;
    println(x, y);
} catch err {
    println("Erro capturado:");
    println(err);
}

try {
    let (a, b) = (1, 2);
    println(a);
    println(b);
} catch err {
    println(err);
}

Executa um script em --pure, bloqueando operacoes impuras de I/O e nao-determinismo no runtime. O erro e tratado com try/catch.

try {
    io_write_text("/tmp/artcode-pure-demo.txt", "nao deve escrever");
} catch err {
    // Em --pure, err recebe a mensagem de bloqueio.
}

Usa dag_topo_sort(nodes, deps) para calcular ordem de boot. A lista de dependências segue o formato (node, depends_on).

let nodes = ["kernel", "drivers", "fs", "shell"];
let deps = [
    ("drivers", "kernel"),
    ("fs", "drivers"),
    ("shell", "fs"),
];

let order = dag_topo_sort(nodes, deps);
for step in (order) println(step);

Exemplo simples de metadados de release para reforçar a política pública de compatibilidade da série 0.2.x.

let release = "0.2.0";
let compat_track = "0.2.x";
let semver = "MAJOR.MINOR.PATCH";

println(f"release={release}");
println(f"track={compat_track}");
println(f"schema={semver}");

Exemplo simples para reforcar a manutencao semantica de release com secoes Added, Fixed e Docs no changelog.

let release = "0.2.0";
let section_added = "Added";
let section_fixed = "Fixed";
let section_docs = "Docs";

println(f"release={release}");
println(f"sections={section_added}, {section_fixed}, {section_docs}");

Demonstra o fluxo minimo para checar migracao entre versoes com art upgrade --check.

let from = "0.1.x";
let to = "0.2.x";

println(f"migrate from={from} to={to}");
println("execute: art upgrade --check ");

Exemplo curto para documentar o worker contínuo de fuzzing em parser/loops. A execução real ocorre no CI via cargo-fuzz.

let worker = "parser_loops";
let command = "bash scripts/run_fuzz_ci.sh 60";

println(f"fuzz-worker={worker}");
println(f"run={command}");

Demonstra request/response via atores: um worker consome envelopes, executa http_get_text e responde ao ator cliente.

let worker = spawn actor {
    let req = actor_receive_envelope();
    let body = http_get_text(req.payload);
    actor_send(req.sender, body);
};

let client = spawn actor {
    actor_send(worker, "http://127.0.0.1:8080/health");
    let response = actor_receive();
    println(response);
};

run_actors(20);

Demonstra closure retornada (escape de escopo) e passagem de callback mantendo ambiente capturado válido no runtime ARC.

func make_adder(base) {
    func add(v) {
        return v + base
    }
    return add
}

func apply_twice(cb, value) {
    return cb(cb(value))
}

let plus_two = make_adder(2)
println(plus_two(40))
println(apply_twice(plus_two, 10))

Slice inicial da integração shell: statement com prefixo $ para executar processos externos. O retorno da última execução é publicado em shell_result como Result.Ok/Err. Em modo --pure, a operação é bloqueada.

// Exemplo 35 - Sintaxe shell (slice inicial)
// Execute com: art run examples/35_shell_syntax.art

$ echo "shell syntax ok"
$ echo shell_pipeline_ok |> tr a-z A-Z
match shell_result {
case .Ok(out): println(f"ok={out}")
case .Err(err): println(f"err={err}")
}

Pipeline de expressões para composição funcional: left |> fn vira fn(left) e left |> fn(a) vira fn(left, a).

func inc(x: Int) -> Int { return x + 1 }
func mul(a: Int, b: Int) -> Int { return a * b }

let chained = 10 |> inc |> mul(3)
println(f"chained={chained}")

Slice de stream lazy para processamento sem arrays intermediários entre transformações: stream |> map |> filter |> collect/count.

func inc(x: Int) -> Int { return x + 1 }
func is_even(x: Int) -> Bool { return ((x / 2) * 2) == x }

let out = [1, 2, 3, 4, 5] |> stream |> map(inc) |> filter(is_even) |> collect
println(out)

for n in [1, 2, 3, 4, 5] |> stream |> map(inc) |> filter(is_even) {
    println(n)
}

Iteradores customizados via protocolo next(), com açúcar yield expr para Option.Some(expr).

let state = map_new();
map_set(state, "i", 0);

func gen() {
    map_set(state, "i", map_get(state, "i").unwrap_or(0) + 1);
    if map_get(state, "i").unwrap_or(0) <= 3 {
        yield map_get(state, "i").unwrap_or(0);
    }
    return Option.None;
}

Quando o identificador nao resolve para simbolo Artcode, chamadas cmd(...) sao mapeadas para executaveis no PATH com retorno Result.Ok/Err.

let ok = echo("shell function style")
match ok {
case .Ok(out): println(f"ok={out}")
case .Err(err): println(f"err={err}")
}

Reuso explícito de arena via stdlib com arena_new, arena_with e arena_release.

let aid = arena_new()

func batch() {
    let _tmp = [1, 2, 3]
}

arena_with(aid, batch)
arena_with(aid, batch)
arena_release(aid)

Define schema de mensagem via struct e valida payload de IPC com idl_schema e idl_validate.

struct BootMsg {
    service: String,
    retries: Int
}

let msg = BootMsg { service: "nexus", retries: 3 }
let ok = idl_validate(msg, "BootMsg")
println(f"ok={ok}")

Capability tokens move-only para cenarios de autorizacao no IPC, com capability_acquire e capability_kind.

let cap = capability_acquire("NetBind")
let kind = capability_kind(cap)
println(f"kind={kind}")

Serializacao binaria baseline com buffer_new, serialize e deserialize.

let payload = map_new()
map_set(payload, "id", 101)
let buf = serialize(payload)
let decoded = deserialize(buf)
println(decoded)

Exemplo de gravacao/reproducao deterministica com checkpoints no trace de time-travel.

// Mostra execução determinística com time-travel
// Use --record para gravar e --replay para reproduzir
let t1 = time_now()
let r1 = rand_next()
println(f"t1={t1} r1={r1}")

Exemplo simples para comunicar highlights de versao e reforcar o workflow de release.

// Metadados de release + highlights da versão
let version = "0.2.0"
let highlights = [
    "time-travel keyframes",
    "ffi call-gate seguro",
    "capabilities move-only",
    "ipc serialization"
]

println(f"release={version}")
println("highlights=")
for item in highlights {
    println(f"- {item}")
}

Fluxo de comparacao automatica de performance entre build warmup e build PGO, com geracao de relatorio em artifacts/perf.md.

// Metadados para rotina de comparação warmup vs PGO
let report = "artifacts/perf.md"
println(f"report={report}")
println("run: bash scripts/perf_compare.sh")

Exemplo de cache incremental que torna rebuilds mais rápidos ao evitar recompilar partes não modificadas do pipeline.

// Cache incremental AOT: primeira compilação gera artefato
// Rebuilds seguintes reaproveitam binário cacheado por hash
func duplicate(x) {
    return x + x;
}

func main() {
    return duplicate(42);
}

Demonstração do modelo ARC adaptativo: alocações mais curtas são gerenciadas em arenas, enquanto escapes são promovidos ao heap global.

// ARC adaptativo: temporários ficam em arena e escapes são promovidos
struct Data {
    id: Int,
    payload: String
}

func create_and_return_data() {
    let d = Data { id: 999, payload: "survivor" }
    return d // promoção por escape
}

let survivor = create_and_return_data()
println(f"Objeto sobrevivente: ID {survivor.id}")