Flujo de control
Tyrus soporta formas familiares de statements para branches, loops y salidas anticipadas. La sintaxis es concisa, mientras el checker valida inicialización, ownership y caminos de retorno.
Condicionales
if (enabled) {
print("enabled");
} else if (fallback) {
print("fallback");
} else {
print("disabled");
}La condición es un boolean, o un T? usado como test de presencia: un opcional es verdadero cuando tiene valor. Lo mismo aplica a while, for, el ternario ? :, &&, || y !. En la rama donde el opcional se sabe presente, el cuerpo de un if, el lado verdadero de un ternario o el lado derecho de un &&, se estrecha a su tipo no-opcional.
Condiciones y statements de cortocircuito
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(); y cond || effect(); también son statements válidos: ejecutan el lado derecho por su efecto de cortocircuito, así que el lado derecho puede 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 ejecuta el cuerpo al menos una 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 repite su cuerpo para siempre hasta un break. A diferencia de while, nunca evalúa una condición, así que es la forma natural para bucles que salen a mitad del cuerpo. Cuando todo break del cuerpo lleva un valor, el loop es una expresión: se evalúa al valor pasado al break que lo termina, por lo que loop { break 42; } tiene tipo i32. continue salta a la siguiente repetición. Un break con valor solo se permite dentro de una expresión loop (E0571); break sin valor funciona como en cualquier otro bucle.
for clásico
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
}Un contador escrito sin anotación toma el tipo del límite del bucle: la i de arriba es el usize que produce length, así que indexa el array directamente y no necesita anotación propia. Un contador medido contra un límite con signo sigue siendo i32, lo que mantiene válida la aritmética que baja de cero. Anota el contador cuando quieras elegir el tipo tú mismo; la anotación siempre gana.
for...of
const names: string[] = ["Neo", "Trinity", "Morpheus"];
for (const name of names) {
print(name); // "Neo", "Trinity", "Morpheus"
}Usa for...of para arrays y valores iterables de runtime. El binding puede desestructurar cada elemento con un patrón de array/tupla [left, right] o de objeto { x, y }, lo que combina bien con las entries [clave, valor] de un 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 también itera un Range directamente, asociando cada uno de sus valores numéricos por turno, a..b excluye b, a..=b incluye.
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 los nombres de los campos de un objeto. Un array no es un tipo objeto, así que usa keys() con for...of cuando el índice es el valor que necesitas; los índices de array son usize en la API nativa de colecciones.
const labels: string[] = ["zero", "one"];
for (const index of labels.keys()) {
print(index); // 0, 1
}break y 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 sale del loop o switch envolvente más cercano. continue avanza el loop envolvente más cercano y también funciona dentro de un switch o match anidado. Un arm de match nunca tiene fallthrough y rechaza un break que podría alcanzar una estructura de control externa (E0269). Un break fuera de todo loop y switch, o un continue fuera de todo loop, es un error (E0268).
return
function label(enabled: boolean): string {
if (enabled) {
return "enabled";
}
return "disabled";
}El checker rechaza funciones con retorno non-void que pueden terminar sin devolver un valor.
defer y 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 registra una expresión o bloque para ejecutarse cuando termina su ámbito léxico actual. errdefer tiene las mismas dos formas, pero se ejecuta solo cuando el ámbito termina con un retorno explícito de error o al propagar un error con ?. Ambos son palabras clave globales del lenguaje y no necesitan import. Los finalizadores se ejecutan en orden LIFO; en una salida de error, los errdefer del ámbito se ejecutan antes que los defer. Los ámbitos anidados terminan antes que su ámbito padre.
El cuerpo captura valores en su punto de registro. No puede usar return, break, continue, throw, await ni ?, porque la limpieza no puede sustituir la salida en curso. errdefer requiere un retorno Result<T, E> o T?. Los finalizadores se admiten actualmente solo en funciones síncronas. panic() aborta inmediatamente y no ejecuta ninguno de los finalizadores, por lo que la limpieza recuperable debe usar una ruta estructurada de error.
switch y match
switch es una instrucción de flujo de control que compara un valor con cases literales. Úsalo para dispatch simple sobre valores primitivos o enums.
const role: string = "admin";
switch (role) {
case "admin": {
print("full access");
break;
}
case "operator": {
print("limited access");
break;
}
default: {
print("read-only access");
}
}Usa switch para dispatch simple
Usa switch cuando el subject es un valor primitivo y cada branch es una comprobación de igualdad literal.
Fallthrough y break
La ejecución continúa desde el case coincidente hacia cada body siguiente. Usa break para salir del switch (o loop) más cercano. Omitirlo es útil cuando varios cases comparten comportamiento:
switch (role) {
case "admin": {
print("privileged");
}
case "operator": {
print("authenticated");
break;
}
default: {
print("anonymous");
}
}Con "admin", esto imprime privileged y authenticated. Un continue dentro de un switch todavía avanza el loop envolvente más cercano. A diferencia de switch, match nunca tiene fallthrough.
Cases duplicados
El linter reporta cases repetidos porque el segundo branch es inalcanzable.
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
Usa match cuando el branch necesita destructuring, guarded arms o narrowing sobre una tagged union. Usa switch para hacer dispatch sobre un enum o un 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;
}
}Los patrones de match no son miembros de enum
Un patrón de match es un wildcard, un binding, un object pattern o un literal. Un miembro de enum como PaymentStatus.Paid no es un patrón, así que haz el dispatch sobre un enum con switch y reserva match para tagged unions y guarded arms.
throw y try/catch/finally
try {
run();
} catch (error: string) {
printError(error);
} finally {
cleanup();
}Un catch sin tipo vincula Error, la interfaz con message y code que usan los errores recuperables, así que error.message y error.code están disponibles sin anotación. Un string lanzado, o cualquier otro tipo, sigue necesitando el tipo escrito, como en 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}`);
}
};El bloque finally se ejecuta antes de que el control salga de try o catch, incluso por return, throw, break o continue.
Evita flujo inseguro en finally
Retornar, lanzar, dar break o continue en finally puede sobrescribir el flujo original y es reportado por reglas de lint.
