Fluxo de controle
Tyrus suporta formas familiares de statements para branches, loops e saídas antecipadas. A sintaxe é concisa, enquanto o checker valida inicialização, ownership e caminhos de retorno.
Condicionais
if (enabled) {
print("enabled");
} else if (fallback) {
print("fallback");
} else {
print("disabled");
}A condição é um boolean, ou um T? usado como teste de presença: um opcional é verdadeiro quando tem valor. O mesmo vale para while, for, o ternário ? :, &&, || e !. No ramo em que o opcional é sabidamente presente, o corpo de um if, o lado verdadeiro de um ternário ou o lado direito de um &&, ele é estreitado para o tipo não-opcional.
Condições e statements de curto-circuito
const user: User? = find();
// Ternary and `&&` narrow the optional to its present type in the truthy branch.
const label: string = user ? user.name : "anonymous";
const isAda: boolean = user && user.name === "Ada";
// A logical expression statement runs the right side for its side effect.
const enabled: boolean = ready();
enabled && notify();
invalid() || abort();cond && effect(); e cond || effect(); também são statements válidos: rodam o lado direito pelo efeito de curto-circuito, então o lado direito pode retornar void.
while
let index = 0;
while (index < 3) {
print(index); // 0, 1, 2
index += 1;
}do...while
let attempts = 0;
do {
attempts += 1;
print(attempts); // 1, 2, 3
} while (attempts < 3);do...while executa o corpo pelo menos uma vez.
loop
let index = 0;
loop {
index += 1;
if (index < 3) {
continue;
}
if (index === 5) {
break;
}
print(index); // 3, 4
}
const found: i32 = loop {
break 42;
};
print(found); // 42loop repete o corpo para sempre até um break. Diferente de while, nunca avalia uma condição, então é a forma natural para loops que saem no meio do corpo. Quando todo break do corpo carrega um valor, o loop é uma expressão: ele avalia para o valor passado ao break que o encerra, então loop { break 42; } tem tipo i32. continue pula para a próxima repetição. Um break com valor só é permitido dentro de uma expressão loop (E0571); break sem valor funciona como em qualquer outro loop.
for clássico
for (let index: u32 = 0; index < 3; index += 1) {
print(index); // 0, 1, 2
}
const names = ["Neo", "Trinity"];
for (let i = 0; i < names.length; i++) {
print(names[i]); // Neo, Trinity
}Um contador escrito sem anotação assume o tipo do limite do laço: o i acima é o usize que length produz, então ele indexa o array diretamente e não precisa de anotação própria. Um contador medido contra um limite sinalizado continua i32, o que mantém válida a aritmética que passa abaixo de zero. Anote o contador quando quiser escolher o tipo você mesmo; a anotação sempre vence.
for...of
const names: string[] = ["Neo", "Trinity", "Morpheus"];
for (const name of names) {
print(name); // "Neo", "Trinity", "Morpheus"
}Use for...of para arrays e valores iteráveis de runtime. O binding pode desestruturar cada elemento com um padrão de array/tupla [left, right] ou de objeto { x, y }, o que combina bem com as entries [chave, valor] de um Map.
const pairs: [i32, i32][] = [[1, 2], [3, 4]];
for (const [left, right] of pairs) {
print(left + right); // 3, 7
}
const scores = Map<string, i32>();
scores.set("Smith", 1);
for (const [name, score] of scores.entries()) {
print(name, score); // "Smith" 1
}for...of também itera um Range diretamente, associando cada um dos seus valores numéricos por vez, a..b exclui b, a..=b inclui.
let sum = 0;
for (const i of 0..5) {
sum += i;
}
print(sum); // 10 (0..5 excludes 5)const main = (): void => {
for (const i of 0..=3) {
print(i); // 0, 1, 2, 3 (0..=3 includes 3)
}
};for...in
interface Config {
host: string;
port: i32;
}
const config: Config = { host: "localhost", port: 8080 };
for (const key in config) {
print(key); // "host", "port"
}for...in itera sobre os nomes dos campos de um objeto. Um array não é um tipo objeto, então use keys() com for...of quando o índice é o valor que você precisa; índices de array são usize na API nativa de coleções.
const labels: string[] = ["zero", "one"];
for (const index of labels.keys()) {
print(index); // 0, 1
}break e continue
for (let index: u32 = 0; index < 10; index += 1) {
if (index === 2) {
continue;
}
if (index === 5) {
break;
}
print(index); // 0, 1, 3, 4
}break sai do loop ou switch envolvente mais próximo. continue avança o loop envolvente mais próximo e também funciona dentro de um switch ou match aninhado. Um arm de match nunca tem fallthrough e rejeita um break que poderia atingir uma estrutura de controle externa (E0269). Um break fora de todo loop e switch, ou um continue fora de todo loop, é um erro (E0268).
return
function label(enabled: boolean): string {
if (enabled) {
return "enabled";
}
return "disabled";
}O checker rejeita funções com retorno non-void que podem terminar sem retornar valor.
defer e errdefer
function process(): void {
defer print("finished");
defer { print("released"); }
print("working");
}
function transfer(ok: boolean): Result<void, i32> {
defer print("always");
errdefer { print("rollback"); }
if (!ok) { return Err(1); }
return Ok();
}defer agenda uma expressão ou bloco para rodar quando seu escopo léxico atual termina. errdefer tem as mesmas duas formas, mas roda apenas quando o escopo termina por um retorno explícito de erro ou pela propagação de erro com ?. Ambos são palavras-chave globais da linguagem e não exigem import. Os finalizadores rodam em ordem LIFO; numa saída de erro, os errdefer do escopo rodam antes dos defer. Escopos aninhados terminam antes do escopo pai.
O corpo captura valores no ponto de registro. Ele não pode usar return, break, continue, throw, await ou ?, porque a limpeza não pode substituir a saída em andamento. errdefer exige retorno Result<T, E> ou T?. Os finalizadores são suportados atualmente apenas em funções síncronas. panic() aborta imediatamente e não roda nenhum dos finalizadores, portanto limpeza recuperável deve usar um caminho estruturado de erro.
switch e match
switch é uma instrução de fluxo de controle que compara um valor com cases literais. Use-o para dispatch simples sobre valores primitivos ou enums.
const role: string = "admin";
switch (role) {
case "admin": {
print("full access");
break;
}
case "operator": {
print("limited access");
break;
}
default: {
print("read-only access");
}
}Use switch para dispatch simples
Use switch quando o subject é um valor primitivo e cada branch é uma checagem de igualdade literal.
Fallthrough e break
A execução continua do case correspondente para cada body seguinte. Use break para sair do switch (ou loop) mais próximo. Omiti-lo é útil quando vários cases compartilham comportamento:
switch (role) {
case "admin": {
print("privileged");
}
case "operator": {
print("authenticated");
break;
}
default: {
print("anonymous");
}
}Com "admin", isso imprime privileged e authenticated. Um continue dentro de um switch ainda avança o loop envolvente mais próximo. Diferentemente de switch, match nunca tem fallthrough.
Cases duplicados
O linter reporta cases repetidos porque o segundo branch é inalcançável.
error
switch (role) {
case "admin": {
print("first");
}
case "admin": {
print("duplicate");
}
}error
error[E0003]: duplicate match case
--> src/main.tyr:4:10
|
2 | case "admin": {
| ^^^^^^^ first use here
4 | case "admin": { // [!code error]
| ^^^^^^^ duplicate case
|
help: remove the duplicate case or use a different valueSwitch vs Match
Use match quando o branch precisa de destructuring, guarded arms ou narrowing sobre uma tagged union. Use switch para fazer dispatch sobre um enum ou um valor literal.
enum PaymentStatus {
Pending,
Paid,
Refused,
}
const status: PaymentStatus = PaymentStatus.Paid;
switch (status) {
case PaymentStatus.Pending: {
print("pending");
break;
}
case PaymentStatus.Paid: {
print("paid");
break;
}
case PaymentStatus.Refused: {
print("refused");
break;
}
}Padrões de match não são membros de enum
Um padrão de match é um wildcard, um binding, um object pattern ou um literal. Um membro de enum como PaymentStatus.Paid não é um padrão, então faça o dispatch sobre um enum com switch e reserve o match para tagged unions e guarded arms.
throw e try/catch/finally
try {
run();
} catch (error: string) {
printError(error);
} finally {
cleanup();
}Um catch sem tipo vincula Error, a interface com message e code usada pelos erros recuperáveis, então error.message e error.code ficam disponíveis sem anotação. Uma string lançada, ou qualquer outro tipo, continua exigindo o tipo escrito, como em catch (error: string).
function load(): void throws Error {
const failure: Error = { message: "config file is missing", code: "ERR_CONFIG_MISSING" };
throw failure;
}
const main = (): void => {
try {
load();
} catch (error) {
console.error(`${error.code}: ${error.message}`);
}
};O bloco finally executa antes de o controle sair de try ou catch, inclusive por return, throw, break ou continue.
Evite fluxo inseguro em finally
Retornar, lançar, dar break ou continue em finally pode sobrescrever o fluxo original e é reportado por regras de lint.
