Livro de receitas executáveis
Encontre a ideia. Rode a prova.
Receitas curtas, ligadas ao código-fonte, para a linguagem como ela é hoje — de um binding de duas linhas a efeitos, servidores web e builds nativos.
/
194receitas
33capítulos
10atos
ligado ao código · verificado pelo compilador · executável
Este catálogo mostra apenas as receitas com conteúdo completo no idioma selecionado.
01
Comece por um resultado
Use uma rota curta quando quiser um modelo mental funcional sem ler o catálogo inteiro.
01
Aprenda o núcleo
Bindings, operadores, fluxo e funções.
Começar pelo essencial02
Modele dados confiáveis
Structs, acessores, enums e Result.
Começar pelo essencial03
Construa serviços
Rotas HTTP, JSON, banco de dados e workers.
Começar pelo essencial04
Explore o Zolo moderno
Comptime, reflexão, máquinas de estado e efeitos.
Começar pelo essencial02
A biblioteca completa de receitas
Abra apenas o ato de que precisa. A busca percorre títulos, descrições, capítulos e sintaxe em toda a biblioteca.
01 Ato 1 Fundamentos
Variáveis e Bindings
6 receitas
- Bindings: let, let mut e var Criando bindings imutáveis com let, mutáveis com let mut, e o atalho var.
- Constantes e Override const para valores fixos em tempo de compilação; override para constantes substituíveis em tempo de carga.
- Anotações de Tipo e Opcionais Inferência automática vs anotação explícita; o tipo T? para valores que podem ser nil.
- Shadowing e Escopo Redeclarar um nome com let (shadowing) e como o escopo léxico define o tempo de vida de um binding.
- Desestruturação Extrair múltiplos valores de arrays, structs e enums em um único padrão.
- Classes de Armazenamento e Descarte var<lazy>, var<persistent>, var<atomic>: controle de inicialização e ciclo de vida; e _ para descartar valores.
Operadores
5 receitas
- Aritmética Operadores aritméticos: +, -, *, /, %, **, unário -, divisão inteira ~/ e atribuição composta.
- Comparação e Lógica Operadores relacionais (==, !=, <, <=, >, >=) e lógicos (&&, ||, !) com curto-circuito.
- Faixas e Spread Operadores de faixa (.. exclusivo, ..= inclusivo), fatiamento de arrays e spread ... em literais.
- Pipeline Operadores de pipeline |> (encadeamento data-first) e &. (efeito colateral sem quebrar o fluxo).
- Segurança com Nil Operadores ?. (navegação segura), ?? (coalescência de nil) e ? (propagação de nil).
Controle de Fluxo
4 receitas
- if / else Condicionais como statement e como expressão, if-let e let-else.
- Laços while, while-let, loops com valor, for em faixas e coleções, break/continue rotulados.
- Match Casamento de padrões: literais, or, faixas, guardas, structs, enums e aninhamento.
- defer Agende limpeza para a saída do escopo, em ordem LIFO.
02 Ato 2 Funções e Lógica
Funções
6 receitas
- Funções Nomeadas Declaração com fn, tipos explícitos ou inferidos, e funções auxiliares locais.
- Lambdas e funções anônimas Funções anônimas com |args| expr e capturas de escopo léxico.
- Parâmetros Flexíveis Valores padrão com p: T = expr e varargs com args: ...T.
- Retornos Múltiplos e Recursão Retornar vários valores via [T] com desestruturação, e funções que chamam a si mesmas.
- Funções de Ordem Superior Funções como argumento ou retorno, composição, map/filter/reduce e closures com estado mutável.
- Geradores e Co-rotinas fn* e yield para sequências lazy; async fn para tarefas cooperativas.
Casamento de Padrões
6 receitas
- Padrões Básicos: Literais, Curinga e Binding Os três blocos fundamentais de todo padrão: casar por valor exato, ignorar com `_`, ou capturar o valor em um nome.
- Padrões Or, Faixas e Guardas Agrupe alternativas com `|`, classifique intervalos numéricos com `..=` e refine padrões com condições extras `if`.
- Binding com @ O operador `@` captura o valor que satisfaz um subpadrão, combinando verificação e binding em um único passo.
- Desestruturação: tuplas, vetores, structs e enums Extraia campos e elementos de estruturas compostas diretamente no padrão — em `let`, `match` e `for`.
- Padrões Aninhados Combine padrões dentro de padrões para extrair dados de estruturas profundas em um único braço de match.
- Padrões em Instruções: if let, while let, let else e match-expressão Além do `match`, padrões aparecem em `if let`, `while let`, `let else` e como expressões retornando valor.
Tratamento de Erros
7 receitas
- Result: sucesso ou erro como valor Crie e inspecione Result.Ok / Result.Err; use is_ok, unwrap, unwrap_or e match exaustivo.
- Operador ? Propague Result e Option automaticamente com ? — sem boilerplate de match aninhado.
- Combinadores de Result Transforme e encadeie resultados com map, map_err, and_then e or_else sem desempacotar.
- Opcionais T?, nil, ??, ?. e if let — represente ausência de valor sem erro.
- panic, try/catch e catch_panic Sinalize invariantes quebrados com panic; capture-os com try/catch/finally e catch_panic.
- defer, defer_ok e defer_err Garanta limpeza de recursos ao sair do escopo; filtre pelo caminho de saída com defer_ok/defer_err.
- Guards e retorno antecipado Valide pré-condições no topo da função e simplifique o caminho feliz com ? em pipelines.
03 Ato 3 Dados e Tipos
Estruturas de Dados
10 receitas
- Vetores (arrays) Coleção ordenada com indexação, fatiamento, spread e operações funcionais.
- Mapas e Sets Mapas chave/valor com literal `#{}` e sets para pertencimento sem duplicatas.
- Tuplas Agrupamento posicional com destructuring — multi-retorno e pares.
- Estruturas (structs) Registros com campos nomeados, aninhamento, mutação e métodos via `impl`.
- Enumerações (enums) Variantes unitárias, com dados posicionais, com campos nomeados e genéricas.
- Newtypes Wrappers opacos para distinguir tipos com o mesmo formato físico no domínio.
- Quando Usar Cada Tipo Guia de decisão: array vs set vs map vs struct vs enum vs newtype.
- Layout de Memória `@repr`, `@align` e `@size` para controle de layout em FFI e GPU.
- Embutimento de Campos com `using` Promova os campos de um struct embutido para o acesso por ponto do struct externo com `using`.
- Iteradores Personalizados Conecte qualquer tipo ao `for x in` implementando Iterator<T> ou IntoIterator<T>.
Strings
8 receitas
- Literais e Escapes Aspas duplas, sequências de escape (\n \t \" \\) e o tipo char.
- Concatenação e Interpolação Operador + para juntar strings e a sintaxe {expr} para embutir valores.
- Especificadores de Formato Precisão de floats (:.Nf), zero-padding (:0Nd) e hexadecimal (:#x) na interpolação.
- Maiúsculas, Minúsculas e Trim .upper, .lower, .trim, .trim_start e .trim_end para normalizar texto.
- Busca e Teste .contains, .starts_with e .ends_with para verificar substrings sem regex.
- Split e Replace .split(sep) divide em array; .replace(old, new) substitui todas as ocorrências.
- Comprimento e Iteração de Caracteres .len() retorna bytes; .chars() devolve array de strings para iterar caractere a caractere.
- Módulo String String.upper, String.sub, String.reverse — o estilo funcional equivalente aos métodos.
Iteradores e Pipes
6 receitas
- Operador Pipe `|>` encadeia chamadas data-first, tornando transformações legíveis da esquerda para a direita.
- Operador Tap `&.` executa um efeito colateral e devolve o valor original — o "espião" do pipeline.
- Fontes e Transformações Iter `Iter::range`, `Iter::from`, `map` e `filter` constroem e transformam sequências de forma lazy.
- Redução e Fatiamento `fold` colapsa uma sequência num valor; `take` e `skip` limitam e pagina iteradores.
- Combinando Iteradores `zip` emparelha dois iteradores; `chain` os concatena; `collect` e `each` são os consumidores terminais.
- Geradores e sequências infinitas `fn*` + `yield` criam sequências lazy on demand; ranges infinitos (`0..`) compõem com `take` em pipelines.
04 Ato 4 Abstração
Orientação a Objetos
5 receitas
- Blocos impl e Métodos de Instância Como agrupar métodos em um tipo com impl, usar self e mutar campos diretamente.
- Funções Associadas e Múltiplos impl Construtores e utilitários sem self, chamados via Type::nome(), e como dividir métodos em blocos impl separados.
- Características (traits) Defina interfaces com trait, implemente-as em tipos concretos com impl Trait for Type, use métodos padrão e combine múltiplos traits.
- Genéricos Parametrize funções, structs e enums com <T> para escrever código que funciona com qualquer tipo.
- Sobrecarga de Operadores, to_string e Encadeamento Vincule operadores a métodos via convenção de nome ou @op, controle a representação textual com to_string, e crie APIs fluentes com encadeamento.
05 Ato 5 Metaprogramação
Decoradores
6 receitas
- Cache de Resultados Memoização automática com @memoize e cache com expiração via @cached(ttl).
- Desempenho e Diagnóstico Instrumentação automática com @benchmark, @log e tolerância a falhas com @retry.
- Estruturas: derivação e validação Geração automática de Eq, Clone e Debug com @derive, e validação de campos com @validate.
- Testes e Benchmarks com o Runner Funções descobertas automaticamente pelo runner: @test para testes unitários e @bench para medição de performance.
- Rotas HTTP e Qualidade de API Rotas declarativas com @get/@post, API obsoleta com @deprecated, retorno obrigatório com @must_use e controle de lint com @diagnostic.
- Composição e Decorators Próprios Empilhamento de decorators, parâmetros @const em tempo de compilação e mixins definidos pelo usuário com super().
Macros
5 receitas
- Definição e Invocação Como declarar um macro com `macro name(p) { ... }` e chamá-lo com `name!(arg)`.
- stringify! e assert! Inspecionar código-fonte em tempo de expansão e criar verificações ricas com `stringify!`.
- Higiene, Recursão e Argumentos de Bloco Variáveis internas não vazam para o chamador; macros podem se invocar; blocos `{}` como argumento.
- DSL de Logging Macros simples compõem uma mini-linguagem de log com níveis padronizados.
- macro_rules! Macros no estilo Rust com múltiplos braços, repetição `$(...),*` e tipos de captura.
Avaliação em Tempo de Compilação
5 receitas
- Bloco comptime comptime { ... } avalia um bloco inline no compilador e substitui o resultado por um literal.
- Funções comptime Declare helpers reutilizáveis com @comptime fn e invoque com comptime f(x) — o call-site vira um literal.
- Recursão, laços e tabelas Funções comptime recursivas, laços for dentro de blocos comptime e geração de arrays literais em tempo de compilação.
- stdlib e embed de arquivos Métodos de string, math.* e comptime fs.read() funcionam em contexto comptime — normalize textos e incorpore arquivos como literais.
- const_assert Falhe a build se um invariante em tempo de compilação não for satisfeito — zero custo em produção.
Schemas
4 receitas
- Valores Padrão Declare campos com `= valor` e obtenha uma instância pronta com `Schema.default()`.
- Introspecção de Campos `Schema.fields()` retorna os nomes dos campos em ordem de declaração, permitindo renderização genérica e migrações.
- Parsear e Serializar `Schema.parse(mapa)` valida a entrada retornando `Result`; `instancia.to_map()` converte de volta para um mapa.
- Restrições `where` Adicione invariantes de domínio a campos com `where |v| <bool>` — verificadas automaticamente durante `parse`.
06 Ato 6 Estrutura de Projeto
Módulos
6 receitas
- mod e use Registre um módulo com `mod` e traga nomes para o escopo com `use`.
- Visibilidade e pub `pub` exporta um item; sem `pub` ele é privado ao módulo.
- Estilos de importação Qualificado, por lista ou múltiplos módulos: quando usar cada estilo.
- Plugins nativos e stdlib `use plugin` para plugins nativos; caminhos `std::` qualificados dispensam `use`.
- Módulos inline e visibilidade granular Módulos declarados dentro do arquivo, `use ... as`, e modificadores `pub(mod)` / `pub(crate)`.
- Projeto multi-arquivo Como `mod` e `use` funcionam em um programa com múltiplos arquivos.
Documentação
4 receitas
- Comentários Comentários de linha (//), bloco (/* */), aninhamento e convenções TODO/FIXME/NOTE.
- Comentários de documentação Doc comments /// e /** */ em funções, structs, enums e traits — aparecem no hover do editor.
- Doc Tags Tags @param, @returns, @throws, @example, @see, @since e @deprecated em doc comments.
- Código Autodocumentado Nomes descritivos, tipos explícitos, aliases, constantes nomeadas e structs/enums como documentação viva.
Diretivas de Módulo
2 receitas
Ganchos de Ciclo de Vida
3 receitas
- Gancho de Encerramento Registrar código de limpeza com `on shutdown` — executado ao sair normalmente ou via `process.exit`.
- Múltiplos Ganchos Compor `on shutdown`, `on panic` e `on signal` no mesmo programa; ordem de disparo e LIFO.
- Pânico e Sinais Interceptar erros fatais com `on panic` e sinais do SO com `on signal`.
07 Ato 7 Concorrência e Reatividade
Expressões Temporais
6 receitas
- Literais de Duração Sufixos de unidade nos números: ns, us, ms, s, min, h, d, w — todos viram i64 em milissegundos.
- Aritmética com Durações Soma, subtração, multiplicação e divisão entre durações; comparações diretas.
- Cast de Unidades Extraia componentes de relógio com `as h`, `as min`, `as s`, `as ms` para formatar durações.
- Sleep Pause a execução com `sleep <dur>` ou `sleep(<dur>)` — cooperativo, cede controle ao scheduler.
- Agendamento: every, after e timeout Loop periódico com `every`, disparo único com `after`, e cancelamento por prazo com `timeout`.
- Padrões Práticos Heartbeat, TTL, backoff exponencial, faixas de alerta e aquecimento combinado com loop periódico.
Concorrência
6 receitas
- Corrotinas e Geradores O primitivo base da concorrência em Zolo: coroutine.create/resume/yield e funções geradoras fn*.
- Async / Await e Fetch async fn, await, Promise.all/race/any e a API fetch para requisições HTTP concorrentes.
- Spawn, Temporização e Cancelamento spawn lança tarefas cooperativas; every/after agendam trabalho no tempo; cancelamento usa flags compartilhadas.
- Pipelines e Máquinas de Estado Geradores encadeados em estágios pull-based e máquinas de estado expressas como sequências de yield.
- Canais Passagem de mensagens ao estilo CSP: channel(N), send/recv, for-in, canais limitados e contrapressão.
- Concorrência Estruturada, Select e Worker Pool scope aguarda todos os filhos; select espera em múltiplos canais; worker pool implementa fan-out + fan-in.
Signals
5 receitas
- Signal Básico Criar um signal com `signal()`, ler com `.get()` e escrever com `.set()`.
- Efeitos O `effect` executa imediatamente na criação e re-executa toda vez que um signal rastreado muda.
- Valores Computados O `computed` cria um signal derivado memoizado: recalcula somente quando uma dependência muda.
- Leitura Sem Rastreio `signal_untrack`, `peek` e `modify`: leia um signal sem criar dependência e atualize funcionalmente.
- Batch, Dispose e Demo Completa Coalesça múltiplas escritas com `signal_batch`, cancele effects com `.dispose()` e veja os três primitivos compostos.
Máquinas de Estado
4 receitas
- Declaração e Transições Como declarar estados, definir o estado inicial e disparar eventos com `.send`.
- Ações de Transição Blocos de código que executam automaticamente quando uma transição ocorre.
- Consulta e Observadores `.can_send` verifica se um evento é aplicável; `.on_transition` registra observadores globais.
- Introspecção `.transitions()` expõe a tabela completa de transições para ferramentas, diagramas e testes.
Efeitos Algébricos
6 receitas
- Fundamentos Declare um efeito, dispare operações com perform e instale um handler com handle … with.
- Múltiplos Efeitos with E1 + E2 combina efeitos na assinatura; handlers aninhados e efeitos transitivos completam o quadro.
- resume e abort resume(v) devolve controle ao perform com um valor; abort(v) descarta a continuação e encerra o handle.
- Handlers como Valor handler { … } cria um valor de primeira classe; compose, override, record e panic_unhandled camadas sobre ele.
- Padrões Funcionais Reader, State e Writer implementados como efeitos; caso real com Db + Fs + Log + Metric e mocks em @test.
- Tipos Avançados multi fn, efeitos genéricos State<T>, polimorfismo de linha, aliases de efeito e combinadores da std::effect.
08 Ato 8 Biblioteca Padrão
Biblioteca Padrão
26 receitas
- Matemática (std::math) Funções matemáticas, constantes, aritmética decimal exata e comparação aproximada entre floats.
- Textos (std::string) Limpeza, divisão, substituição, busca, conversão de maiúsculas/minúsculas, iteração por caractere e formatação.
- Vetores (std::array) Mutação, transformação, filtragem, agregação, busca e achatamento de arrays.
- Vetores (std::vec) Vetores 2D/3D/4D: construtores, aritmética, produto interno e externo, comprimento, normalização e swizzle rgba.
- Mapas (std::map) Criação, inserção, leitura, remoção, iteração e a diferença entre literais #{} e Map::new().
- Conjuntos (std::set) Unicidade, pertença, remoção, operações de conjunto (união e interseção) e conversão com arrays.
- Iteradores (std::Iter) Sequências preguiçosas: range, map, filter, fold, take, skip, zip, collect e each.
- Resultado (std::Result) Tratamento de erros sem exceções: Ok, Err, unwrap, map, and_then e o operador ?.
- JSON (std::json) Serializar e desserializar JSON: encode, decode, tratamento de erros, literal json"...", path e interop com schemas.
- YAML (std::yaml) Parsear e serializar YAML: configurações hierárquicas, listas e round-trip.
- TOML (std::toml) Parsear e serializar TOML: seções, tipos explícitos e round-trip.
- CSV (std::csv) Parsear e serializar CSV: linhas, cabeçalhos, escaping de aspas e round-trip.
- Expressões Regulares (std::regex) Validar, extrair, substituir e dividir strings com expressões regulares.
- Data e Hora (std::datetime) Obtém o instante atual, formata e analisa datas, e realiza aritmética de calendário com std::datetime.
- Caminhos (std::path) Manipula caminhos de forma portável: une componentes, extrai partes, normaliza e resolve caminhos relativos.
- Sistema de Arquivos (std::fs) Lê, grava, remove arquivos, lista diretórios e trabalha com arquivos temporários usando std::fs.
- Variáveis de Ambiente (std::env) Lê, define e remove variáveis de ambiente; obtém informações sobre o sistema com std::env.
- Processo (std::process) Acessa argumentos, diretório de trabalho, executa comandos externos e inspeciona o processo atual com std::process.
- Reactor de I/O (std::io_runtime) Timers baseados no reactor de I/O: sleep de uma vez, timers periódicos com cancelamento.
- Cliente HTTP (std::http) Realize requisições GET, POST e outras via std::http.client — cabeçalhos personalizados, corpo JSON e tratamento de erros.
- URLs (std::url) Parse, codificação percentual e construção de query strings com std::url.
- Criptografia (std::crypto) Geração de IDs únicos e aleatoriedade criptograficamente segura com std::crypto.
- Hashes (std::hash) SHA-256, SHA-512, MD5, CRC32 e HMAC para integridade e autenticação de mensagens com std::hash.
- Base64, Hex e Base32 (std::base64) Codificação e decodificação Base64 padrão, URL-safe, Hex e Base32 para representar dados binários como texto.
- Registros de log (std::log) Logging estruturado por nível de severidade, controle de verbosidade e formatação customizada com std::log.
- Estatísticas (std::stats) Tendências centrais, dispersão, percentis, correlação e regressão linear com std::stats.
09 Ato 9 Plataforma e Aplicações
Servidor HTTP
5 receitas
- Cliente HTTP — GET Fazendo requisições GET com cabeçalhos opcionais e lendo o objeto de resposta.
- Cliente HTTP — POST JSON e fetch Enviando dados com http.post e usando http.fetch para métodos arbitrários e timeout.
- Servidor — Roteador e Decoradores Criando um servidor HTTP com http.router() via pipes ou com decoradores @get/@post.
- Parâmetros de Rota e Middleware Lendo :id e query string via req.params/req.query; adicionando middlewares com http.middleware.
- Respostas e Workers http.response, http.html e http.redirect para controle de status; http.workers para paralelismo.
Banco de Dados
7 receitas
- Conexão e Ping Abrir uma conexão com Database.open, verificar com ping e fechar com defer.
- DDL e Inserção Criar tabelas com db.execute e inserir linhas contando as afetadas.
- Consulta de Linhas db.query retorna uma lista de maps {coluna: valor} que pode ser iterada com for.
- Consultas Parametrizadas Usar ? + array de bindings para passar valores externos com segurança.
- Transações db.transaction garante atomicidade: commit automático no retorno, rollback automático em erro.
- sql"…" — Template Seguro e Scalar O literal sql"..." auto-parametriza interpolações e expõe métodos :query, :execute e :scalar.
- Proteção contra SQL Injection Interpolações em sql"..." são sempre parâmetros vinculados — metacaracteres SQL no valor são literais, jamais executados.
CLI e Ferramentas
9 receitas
- Argumentos do Processo Ler a linha de comando com `process.argv()` e isolar os argumentos do usuário.
- Variáveis de Ambiente e Plataforma Ler, definir e remover variáveis de ambiente; detectar SO, arquitetura e diretório home.
- Ciclo de Vida do Processo Encerrar com `process.exit`, registrar hooks `on shutdown`, capturar pânicos e sinais do SO.
- Comando Doctor Padrão de diagnóstico: agregar verificações de ambiente e sair com código não-zero quando algo falha.
- Builder @cli Parsing declarativo com `@cli` + `@arg`: flags, posicionais, `--help` automático e subcomandos.
- Literais de Comando e Segurança Monte comandos lazy com sh"…", interpole argv com segurança e trate erros de processo tipados.
- Efeitos e Pipelines de Processos Simule execução de processos, conecte processos reais e transforme dados estruturados do sistema.
- Streaming e Scripts Executáveis Consuma a saída de processos aos poucos e execute arquivos .zolo com shebang no Unix.
- Comandos Paralelos e UI de Terminal Execute comandos independentes em paralelo e adicione estilos ANSI acessíveis a CLIs interativas.
Recarregamento automático
6 receitas
- Reload Básico O "hello world" do zolo dev: edite um módulo, salve e veja a nova versão em ação sem reiniciar a VM.
- Preservação de Estado pub let com tipo de runtime estável sobrevive ao swap — o valor acumulado continua, apenas o inicializador literal é ignorado.
- Hooks de Ciclo de Reload Três pontos de extensão do pipeline de swap: __on_reload para notificação, #[hot_dispose] para capturar estado antes, e #[hot_accept] para restaurá-lo depois.
- Reload de Assets HMR de arquivos de dados: edite config.json, shaders ou CSVs e o hook __on_asset_reload reage sem reiniciar a VM.
- Undo/Redo e Casos Avançados Viagem no tempo pelo histórico de swaps via :undo / :redo / :history, mais reload transparente em loops sem yield e referências de closure capturadas fora do live-binding.
- Loop de Render e Servidor HTTP Hot reload num loop de renderização wgpu com 1000 cubos e num servidor HTTP em execução — sem perder o listener nem o estado GPU.
10 Ato 10 Build, Testes e Distribuição
Testes
4 receitas
- Matchers com expect() A biblioteca expect() e seus matchers: igualdade, comprimento, conteúdo, prefixo e negação.
- Suítes com @suite Agrupe testes em módulos anotados com @suite, inclusive com suítes aninhadas.
- Atributos de Teste Controle a execução com skip, should_throw, only e tag nos decorators @test e @suite.
- Hooks de Ciclo de Vida Execute código antes e depois de cada teste ou da suíte inteira com @before_each, @after_each, @before_all e @after_all.
Compilação
4 receitas
- Executar ou compilar VM interpretada (`zolo run`) e backend nativo (`zolo build`): quando usar cada um e o que muda entre eles.
- Flags --emit Parar o pipeline de compilação mais cedo: `--emit ir` imprime o ZoloIR; `--emit obj` grava um arquivo objeto sem linkar.
- Build de Release O flag `--release` ativa otimizações do Cranelift para gerar um binário mais rápido, ao custo de um build mais lento.
- compile e bundle `zolo compile` mostra o Lua gerado para a VM; `zolo bundle` agrupa a entrada e seus módulos em um único arquivo Lua portátil.
WebAssembly
4 receitas
- Emitir Wasm Compile um programa Zolo para `.wasm` com `zolo build --emit wasm`; entenda o modo VM-embedded e o host-shim ABI padrão.
- Perfis de Host Selecione o perfil de runtime com `--host wasi|browser` e habilite o backend AOT experimental com `--aot`.
- Exportar Funções Use `@export` para expor funções Zolo a JavaScript/TypeScript via AOT wasm com `--host browser`.
- Vetores (arrays) em Wasm Use arrays em funções AOT e exporte funções que recebem ou retornam `[int]`, `[bool]` e `[str]` para JavaScript.
Distribuição
3 receitas
- Arquivos .zar e .zex Empacote código como biblioteca reutilizável (`.zar`) ou executável portátil (`.zex`) com `zolo build --emit`.
- Binário Standalone Embuta o runtime no `.zex` com `--standalone` para distribuir sem depender do `zolo` instalado.
- GUI e Windowed Distribua apps desktop sem janela de console com `--windowed` / `--gui`; execute arquivos prontos com `zolo run`.
Integração com o SO
1 receitas