Livro de receitas executáveis
Aprenda Zolo por exemplos
Leia programas completos com suas explicações. Comece por valores e funções, depois explore dados, erros, efeitos e integrações.
/
257receitas
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 assuntos avançados
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
6 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.
- Comparações encadeadas Escreva mínimo <= valor < máximo em uma cadeia. Cada operando compartilhado é avaliado uma vez, e uma comparação falsa interrompe a cadeia. Assim, checagens de intervalo não repetem uma expressão potencialmente cara.
- 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
6 receitas
- if / else Condicionais como statement e como expressão, if-let e let-else.
- Condições com bindings Condições separadas por vírgulas executam da esquerda para a direita, com curto-circuito. Bindings bem-sucedidos ficam disponíveis nas próximas condições e no corpo. Um guard que cria bindings precisa sair em todos os caminhos de falha.
- Laços while, while-let, loops com valor, for em faixas e coleções, break/continue rotulados.
- Iteração filtrada com for case for case padrão in valores ignora valores que não correspondem e cria bindings apenas no corpo bem-sucedido. Um for comum com padrão refutável mantém seu panic em caso de incompatibilidade. O iterável é avaliado uma vez e continue segue a regra normal do loop.
- 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
15 receitas
- Funções Nomeadas Declaração com fn, tipos explícitos ou inferidos, e funções auxiliares locais.
- Funções com corpo de expressão Use = expressão em uma função ou método pequeno. A expressão fornece o retorno, enquanto return, propagação de Result, generics e defaults preservam a mesma semântica de um corpo em bloco.
- Lambdas e funções anônimas Funções anônimas com |args| expr e capturas de escopo léxico.
- Lambdas curtas de predicado Acessos iniciados por underscore usam o mesmo parâmetro implícito. Combine campos, contas e testes booleanos no callback; use uma lambda explícita quando o escopo ficar ambíguo.
- Lambdas unárias completas Com uma assinatura comprovada de callback de um argumento, underscore pode representar o parâmetro inteiro, inclusive em contas e chamadas aninhadas comuns. Callbacks aninhados ganham seu próprio parâmetro. Blocos, lambdas explícitas, coleções e pipes continuam sendo fronteiras de escopo.
- Blocos finais nomeados Vários callbacks podem aparecer depois da chamada como blocos com rótulos. Os rótulos resolvem os parâmetros de função, permitindo outra ordem. Criar o callback não executa seu corpo; capturas mutáveis preservam suas células.
- Parâmetros Flexíveis Valores padrão com p: T = expr e varargs com args: ...T.
- Rótulos externos de argumentos Separe o rótulo público do nome local do parâmetro: from source: int. O chamador usa from:, enquanto a função lê source. Rótulos fazem parte da interface e continuam disponíveis em valores de função.
- Argumentos nomeados abreviados Uma chamada com name: passa a variável name do chamador. Valores explícitos e abreviados podem ser misturados e reordenados pelo rótulo. Uma variável ausente é um erro; o formatador preserva a abreviação.
- Argumentos nomeados obrigatórios Parâmetros depois de * precisam ser passados com seus rótulos externos. Defaults ainda podem ser omitidos. O contrato acompanha métodos, declarações exportadas e valores de função tipados; passar a função como callback não remove a exigência.
- Retornos Múltiplos e Recursão Retornar vários valores via [T] com desestruturação, e funções que chamam a si mesmas.
- Cláusulas de função por padrão Declarações consecutivas da mesma função escolhem o corpo pelos padrões dos parâmetros e guards opcionais, na ordem escrita. As cláusulas formam uma função e precisam cobrir os casos; guards sozinhos não garantem cobertura. Contratos e rótulos públicos precisam coincidir.
- Condições de entrada e retorno Confira os argumentos com requires e o retorno normal com ensures.
- 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
9 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.
- Bindings de padrões com is Use is com um padrão de valor para testar e criar bindings em uma condição. Capturas ficam visíveis apenas no caminho bem-sucedido, incluindo condições seguintes. Testes existentes is Tipo e is not Tipo mantêm seus significados.
- Capturas tipadas em strings Um literal pat compara a string inteira e converte as capturas antes de expor os bindings. Conversão escalar ou construção validada que falha significa não corresponder. O primeiro delimitador é usado sem backtracking; capturas adjacentes sem delimitador são rejeitadas.
- Padrões de captura como valores Guarde um literal pat como valor reutilizável. Seu método parse retorna Result com um record de capturas de tipos exatos. Entrada incompatível e conversões que falham retornam erros estruturados. Construir o padrão retém as funções de conversão sem executar seus predicados de validação.
Tratamento de Erros
10 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.
- Fronteiras locais de Result attempt executa um bloco e envolve seu resultado normal em Ok. Um ? de Result que falha sai do attempt mais próximo como Err, permitindo continuar no chamador. Um Result no final fica aninhado. Panics não são capturados; propagação de opcionais exige conversão explícita do erro.
- Combinadores de Result Transforme e encadeie resultados com map, map_err, and_then e or_else sem desempacotar.
- Recuperação de Result em expressões recover avalia o Result uma vez e extrai Ok. Seus padrões correspondem ao conteúdo de Err e precisam cobrir esse tipo. Ramos que continuam retornam o mesmo tipo do sucesso. Retornos, propagação e limpeza continuam pertencendo ao escopo externo.
- 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.
- Escopos de recursos visíveis using recurso = aquisição { corpo } instala a limpeza após uma aquisição bem-sucedida. O tipo precisa implementar core::cleanup::Cleanup. A limpeza acompanha saídas léxicas e transferências de ownership a desarmam. Um método apenas chamado close não comprova o protocolo.
- 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
20 receitas
- Vetores (arrays) Coleção ordenada com indexação, fatiamento, spread e operações funcionais.
- Entradas condicionais em arrays Use if condição => valor e for item in itens => valor dentro de um array. Entradas são produzidas na ordem escrita. Condições falsas omitem entradas; nil ainda ocupa uma posição. Arrays aninhados continuam sendo valores sem um spread explícito.
- Mapas e Sets Mapas chave/valor com literal `#{}` e sets para pertencimento sem duplicatas.
- Tipos de map explícitos Escreva tipos de map como #{K: V}. Chaves com campos nomeados sempre descrevem um record, inclusive campos chamados int ou String. Chaves vazias representam um record vazio. Map<K, V> continua disponível.
- Compreensões de maps Construa maps com entradas for e if dentro de #{ }. Chaves calculadas usam [expressão]: valor. Iteráveis, chaves e valores executam uma vez na ordem escrita; chaves repetidas seguem a substituição normal de maps. Bindings do loop e filtro ficam na própria entrada.
- Tuplas Agrupamento posicional com destructuring — multi-retorno e pares.
- Records anônimos independentes Sem um tipo nominal esperado, .{ campos } infere um record anônimo com tipos exatos e acesso normal aos campos. Um struct esperado ainda seleciona construção nominal contextual. Um tipo esperado inválido gera diagnóstico, sem virar silenciosamente um tipo estrutural.
- Estruturas (structs) Registros com campos nomeados, aninhamento, mutação e métodos via `impl`.
- Construção contextual Quando um tipo struct exato é esperado, .{ campos } constrói esse struct sem repetir seu nome. Defaults, privacidade e campos obrigatórios continuam valendo. O compilador nunca adivinha uma identidade nominal pelos nomes dos campos.
- Atualizações imutáveis aninhadas A atualização with avalia a base uma vez e copia a raiz e os records alterados no caminho. Filhos intactos continuam compartilhados. O resultado preserva o tipo nominal; caminhos conflitantes e cópias de recursos lineares são rejeitados.
- Atualizações imutáveis calculadas Uma atualização with aceita operadores compostos como value += 1. Ela lê o campo antigo uma vez e calcula a substituição sem alterar o original. Restrições de visibilidade, tipos, caminhos conflitantes e cópias lineares continuam valendo.
- Projeção tipada de records user.{ id, name } avalia user uma vez e cria um record anônimo com os campos físicos visíveis selecionados. Tipos exatos são preservados. Seleções repetidas, campos inacessíveis ou computados e cópias lineares proibidas são rejeitados.
- Caminhos de campos tipados field User::address.city cria um FieldPath<User, str> sem ler uma instância. get lê o campo; set devolve uma atualização imutável e compartilha filhos intactos. Caminhos preservam privacidade e o tipo exato; membros computados e armazenamento linear são rejeitados.
- 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.
- Newtypes escalares validados Um newtype com where incorpora o predicado à construção. Seu construtor new retorna Result; trate a falha ou propague-a. Operações derivadas mantêm a validação. Um newtype sem where preserva o construtor direto.
- 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
9 receitas
- Literais e Escapes Aspas duplas, sequências de escape (\n \t \" \\) e o tipo char.
- Literais de string nominais validados Um literal como Email\"ana@empresa.com\" só é aceito se o predicado do newtype de string validado aceitar seu conteúdo estático na compilação. Strings dinâmicas continuam usando o construtor falível. Templates prefixados por funções existentes preservam sua semântica.
- 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
6 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.
- Arrays fixos e tamanhos genéricos constantes Confira o tamanho exato de um pacote e infira esse tamanho em funções reutilizáveis.
- 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
7 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.
- Deriving uniforme Adicione um sufixo deriving a structs e enums para solicitar os produtores existentes. O sufixo usa a mesma validação e implementação gerada dos decorators de derive. Traits não suportados e tipos de campos incompatíveis geram diagnóstico, sem criar implementações não verificadas.
- 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
5 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`.
- Invariantes entre campos de schemas Adicione predicados where após um schema para validar o valor completo. Conversão de campos e defaults acontecem primeiro. Invariantes retornam bool e executam na ordem; falhas viram DecodeError estruturado no caminho do objeto. Restrições de campos mantêm seu próprio escopo.
06 Ato 6 Estrutura de Projeto
Módulos
23 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.
- C# com extern Funções tipadas, closures e objetos .NET chamados como código Zolo.
- Python com extern Funções Python tipadas, pacotes nativos e chamadas async com CPython.
- JavaScript e TypeScript com Node Funções tipadas, módulos Node e callbacks assíncronos com extern.
- Bibliotecas de outras linguagens Declare versões uma vez, instale com Zolo e use os imports nativos.
- Java com extern Java 8 em diante, objetos com identidade e bibliotecas Maven pelo provider JVM.
- Kotlin com extern Funções Kotlin, APIs suspend, objetos vivos e bibliotecas Maven.
- C e C++ com extern Funções nativas, objetos C++ e bibliotecas vcpkg pelo provider native.
- Rust com extern Funções Rust tipadas, callbacks e dependências Cargo travadas.
- Go com extern Funções Go, dependências de módulos e callbacks pelo Zolo.
- C# · .NET Integre funções C# tipadas, objetos CLR, callbacks e chamadas assíncronas. Prepare com as ferramentas .NET e mantenha o runtime compatível na distribuição.
- Python · CPython Execute Python no processo com imports nativos e conversão tipada. Windows com CPython 3.12 está verificado; um interpretador compatível e as dependências nativas dos pacotes são necessários.
- JavaScript / TypeScript · Node Use JavaScript e TypeScript pelo Node embutido, incluindo módulos nativos e Promises. Shim, runtime e ABI de addons precisam coincidir. int da Zolo usa bigint em assinaturas inline.
- Java / Kotlin · JVM Compartilhe uma JVM para Java e Kotlin, com imports nativos, objetos vivos e dependências Maven. Preparação de fontes e editor exige as ferramentas correspondentes; aplicações preparadas precisam de um JRE compatível. JVM 8, 11 e 23 estão verificadas em Windows x64.
- C / C++ · Clang · C ABI Prepare bibliotecas C17 e C++17 com Clang. C++ expõe classes concretas suportadas; ownership nativo e ponteiros ou templates não suportados exigem adapters explícitos. O código preparado executa sem o compilador de fontes.
- Rust · rustc · Cargo Compile funções Rust tipadas e records copiados em uma biblioteca específica do alvo. Dependências Cargo participam do fluxo com lock. Artefatos distribuídos dispensam rustc e fontes; objetos com receivers retidos e generics abertos exigem adapters.
- Go · Go · cgo Prepare exports Go com cgo e um compilador C compatível. Funções tipadas, structs públicos copiados e módulos usam a ponte comum. Artefatos preparados dispensam Go e o cache de módulos; receivers retidos e variádicos exigem adapters.
- Dependências estrangeiras e locks Declare dependências uma vez no escopo do arquivo. Providers precisam ser importados explicitamente; aliases escolhem o mesmo ambiente do provider original. Imports nativos ainda selecionam os símbolos usados em cada fragmento.
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
8 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.
- Sufixos de unidades declarados Associe @unit a um newtype escalar para dar um sufixo tipado aos literais. O sufixo preserva o tipo nominal e a precisão do escalar. Um sufixo sozinho não define conversão: declare dimensões e escalas para converter automaticamente.
- Dimensões e escalas de unidades Declare unidades base, dimensões derivadas e escalas exatas com @unit. Multiplicação e divisão derivam dimensões; as converte apenas dimensões compatíveis e verifica representabilidade. Sufixos de duração mantêm o comportamento em milissegundos fora de um contexto dimensional.
- 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
11 receitas
- Corrotinas e Geradores O primitivo base da concorrência em Zolo: coroutine.create/resume/yield e funções geradoras fn*.
- Delegação lazy de generators yield ... filho delega um valor produzido por vez e mantém o cursor do filho entre retomadas. Não materializa um array. Fechar o generator externo fecha o filho ativo e executa sua limpeza; yield comum mantém seu comportamento.
- Async / Await e Fetch async fn, await, Promise.all/race/any e a API fetch para requisições HTTP concorrentes.
- Prazos de await await tarefa within duração retorna um Result tipado de timeout. Ao expirar, o scheduler solicita cancelamento e aguarda a limpeza cooperativa da tarefa. Uma tarefa que retorna Result produz um Result aninhado; escolha qual camada propagar. Trabalho nativo sem checkpoints não pode ser interrompido à força.
- Lendo uma fonte assíncrona `for await` pede um valor por vez à fonte e aguarda `next()` antes de executar o corpo do laço.
- 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.
- Resultados paralelos nomeados Tarefas nomeadas em parallel produzem um record tipado após a junção estruturada. Cada tarefa captura o escopo externo; rótulos não viram variáveis para tarefas irmãs. Falhas cancelam e aguardam as irmãs cooperativamente. Resultados transitivamente lineares são rejeitados.
- Limitando o trabalho concorrente `parallel(limit: 2) [for id in ids => await load_profile(id)]` processa um array com no máximo dois trabalhos ativos e devolve os resultados na ordem de entrada.
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
6 receitas
- Declaração e Transições Como declarar estados, definir o estado inicial e disparar eventos com `.send`.
- Eventos tipados e dados de estado Uma máquina tipada possui seus enums State e Event. Padrões de transição vinculam dados do evento e estado apenas nessa transição. Dados iniciais executam uma vez por instância. send retorna false quando nenhuma transição se aplica; can_send verifica padrões sem executar guards ou ações.
- 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.
- Máquinas indexadas por estado new_static cria uma máquina com ownership e testemunho do estado. send a consome e retorna o tipo do estado destino; uma falha de guard devolve a máquina e o evento originais. Funções podem exigir Order<.Paid>. erase_state devolve uma máquina dinâmica quando a checagem estática não é mais necessária.
Efeitos Algébricos
8 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.
- Handlers antes do bloco with handler_value { corpo } avalia e instala o handler antes do corpo. A semântica é a mesma de handle corpo with handler_value. Blocos aninhados restauram o handler externo, e retornos e limpeza mantêm suas fronteiras léxicas. O valor precisa ser um Handler comprovado.
- Substituições tipadas de handlers Um handler com seletores de operações substitui apenas essas operações e preserva a cobertura de efeitos e o tipo de resposta restantes. Assinaturas e corpos são checados contra o efeito real. A composição preserva o frame e a semântica léxica de abort.
- 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
7 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.
- Elementos condicionais com v:if Use `v:if={condition}` quando uma condição decide se um elemento inteiro existe.
- Formulários de Action Tipados Envie campos escalares para uma @action com HTML nativo e conversão no servidor pela assinatura.
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
5 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.
- Testes com nomes legíveis Uma declaração test usa um título entre aspas e o runner existente. Descoberta, filtros, relatórios e navegação do editor preservam esse título. Atributos e suites existentes continuam disponíveis. Executar o arquivo normalmente não roda seus testes: use zolo test.
- 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