Skip to content

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 ​

tyrus
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 ​

tyrus
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 ​

tyrus
let index = 0;

while (index < 3) {
    print(index); // 0, 1, 2
    index += 1;
}

do...while ​

tyrus
let attempts = 0;

do {
    attempts += 1;
    print(attempts); // 1, 2, 3
} while (attempts < 3);

do...while executa o corpo pelo menos uma vez.

loop ​

tyrus
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); // 42

loop 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 ​

tyrus
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 ​

tyrus
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.

tyrus
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.

tyrus
let sum = 0;

for (const i of 0..5) {
    sum += i;
}

print(sum); // 10 (0..5 excludes 5)
tyrus
const main = (): void => {
    for (const i of 0..=3) {
        print(i); // 0, 1, 2, 3 (0..=3 includes 3)
    }
};

for...in ​

tyrus
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.

tyrus
const labels: string[] = ["zero", "one"];

for (const index of labels.keys()) {
    print(index); // 0, 1
}

break e continue ​

tyrus
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 ​

tyrus
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 ​

tyrus
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.

tyrus
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:

tyrus
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

tyrus
switch (role) {
    case "admin": {
        print("first");
    }
    case "admin": { 
        print("duplicate");
    }
}

error

text
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 value

Switch 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.

tyrus
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 ​

tyrus
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).

tyrus
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.