Operadores y Expresiones
Tyrus mantiene operadores familiares cuando la semántica puede comprobarse estáticamente y bajarse a código nativo.
Grupos de Operadores
| Categoría | Operadores |
|---|---|
| Aritméticos | + - * / % ** |
| Unarios | - + ++ -- ! not ~ |
| Bitwise | & | ^ ~ << >> >>> |
| Comparación | > < >= <= === !== |
| Lógicos | && and || or |
| Ternario | ? : |
| Asignación | = += -= *= /= %= **= &= |= ^= <<= >>= >>>= &&= ||= ??= |
| Null safety | ?? ?. |
| Borrow | & &mut |
| Pertenencia | in not in |
| Chequeo de tipo | is not is |
| Range | .. ..= |
and, or y not son equivalentes escritos exactos de &&, || y !, el lexer mapea cada par al mismo token, así que ambas grafías pueden mezclarse libremente en la misma expresión: active and not suspended or isAdmin y active && !suspended || isAdmin compilan de forma idéntica.
Comparaciones Encadenadas
Tres o más de <, <=, >, >=, === encadenados directamente (a < b < c) son azúcar sintáctico para a < b && b < c, leyéndose más cerca de la notación algebraica que el equivalente escrito con &&.
const temp: u32 = 25;
print(0 < temp < 100); // true
const age: i32 = 25;
print(18 <= age < 65); // true
const getValue = (): i32 => 25;
print(10 < getValue() <= 50); // true - getValue() runs once, not twiceCada término en la cadena se evalúa exactamente una vez, incluso cuando participa en dos comparaciones, un término con efecto secundario (una llamada a función) nunca se ejecuta dos veces. La cadena también hace cortocircuito como &&: en cuanto una comparación falla, los términos siguientes nunca se evalúan. Dos términos (a < b) no se ven afectados por este azúcar y siguen siendo una comparación simple; la cadena solo aplica a partir de tres términos. !== nunca encadena, no existe una lectura algebraica para a != b != c, así que siempre permanece como una comparación simple de dos términos.
Pipeline
Consulta la guía del operador pipe para conocer el operador |>, el token topic % y la composición de pipelines.
Ternario
const label: string = score >= 90 ? "A" : "B";La condición ternaria debe ser boolean y ambos branches deben tener el mismo tipo.
typeof
El operador typeof retorna una string con el nombre del tipo tyrus del valor en runtime: el nombre del tipo mismo, no una categoría genérica. Los tipos numéricos siguen distintos en lugar de colapsar a "number", un array informa el tipo de su elemento, una interfaz informa su propio nombre y un opcional conserva su ?. Solo dos formas responden con una categoría, por no tener nombre que dar: un tipo de objeto anónimo ("object") y una función ("function").
const t1: string = typeof 42; // "i32"
const t2: string = typeof "hello"; // "string"
const t3: string = typeof true; // "boolean"
const t4: string = typeof [1, 2]; // "i32[]"
const t5: string = typeof 3.14; // "f64"
const t6: string = typeof 12.50d; // "decimal"typeof también puede usarse como type query.
const count: i32 = 42;
type CountType = typeof count;
const other: CountType = 7;Las comparaciones con typeof hacen narrowing de valores union en el flujo de control.
function describeValue(value: string | i32): void {
if (typeof value === "string") {
print(value.length); // string length
} else if (typeof value === "i32") {
print(value + 1); // value + 1
}
}Esto también funciona con enums, typeof retorna la representación subyacente:
enum Status: string {
Active = "active",
Inactive = "inactive",
}
const current: Status = Status.Active;
const kind: string = typeof current; // "string", the enum's backing typeis / not is
El operador is comprueba si un valor en runtime coincide con un tipo específico dentro de una union, retornando boolean. Es el mecanismo principal para narrowing de union types.
function process(value: string | number): void {
if (value is string) {
print(value.length); // string length
} else {
print(value + 1); // number
}
}Dentro del branch true, el compilador estrecha value a string. Fuera, value permanece string | number.
not is es la forma negada:
function handle(value: string | number): void {
if (value not is string) {
print(value + 1); // number
} else {
print(value.length); // string
}
}is/not is también funcionan en condiciones de while y asignaciones booleanas. La comprobación se ejecuta en runtime comparando la tag de tipo de la union contra el tipo objetivo.
Un error capturado conserva el tipo con el que fue lanzado, así que is también distingue errores. En catch (error), error is ConfigError es true cuando el valor lanzado era un ConfigError (un error de módulo como FsError, o una interfaz que extiende Error), y dentro de ese branch error tiene todos los campos del subtipo. Un catch (error: A | B) se estrecha a la variante de la misma forma. Esto vale también en una función async, incluso para un error que llega como rechazo de un await, y en un catch (error) que espera antes de la comprobación. Solo un Error que no vino de un catch no puede distinguir el subtipo (E3297). Un handler que comprueba los errores que conoce termina con throw error; para el resto: el valor sigue con su subtipo, así que el siguiente catch todavía lo distingue, y un tipo de error añadido después se reenvía en lugar de silenciarse.
import { FsError, readFileSync } from "tyrus:fs";
interface ConfigError extends Error {
path: string;
}
function readText(path: string): string throws FsError {
let contents: string = "";
match (readFileSync(path)) {
Ok(text) => { contents = text; }
Err(error) => { throw error; }
}
return contents;
}
function loadConfig(path: string): string throws ConfigError {
const failure: ConfigError = { message: "config is missing", code: "ERR_CONFIG", path: path };
throw failure;
}
function readSettings(): string throws Error {
try {
return readText("settings.json") + loadConfig("app.json");
} catch (error) {
if (error is ConfigError) {
console.error(`${error.code}: ${error.path}`);
return "";
}
// What this handler does not recognize goes on, subtype and all.
throw error;
}
}
const main = (): void => {
try {
console.log(readSettings());
} catch (error) {
if (error is FsError) {
console.error(`${error.code}: ${error.message}`);
} else {
console.error(error.message);
}
}
};Type Assertions
const value: i32 = 42;
const converted: f64 = value as f64;
const narrowed: u32 = 4294967295 as u32;Una assertion numérica preserva el valor o aborta; nunca wrappea. Las comprobaciones se ejecutan en todos los perfiles, así que una ejecución en debug predice lo que hace el binario publicado. Las assertions non-primitive son casts de identidad y deben usarse con cuidado.
Conversión y Parsing
const label: string = (42).toString();
const flag: string = String(true);
const parsedCount: i64? = parseInt("42 items");
const ratio: f64? = parseFloat("3.5e2!");
const strict: f64? = Number("2.5abc");Parsing retorna valores opcionales en vez de NaN, preservando null safety.
La anotación elige el ancho del parseo, con el ancho elegido por la anotación. parseInt estrecha a cualquier tipo entero y parseFloat/Number a f32 o f64; sin anotación, permanecen i64? y f64?. Un texto cuyo valor no cabe en el tipo objetivo simplemente no parsea como ese tipo, por lo que el resultado es ausencia en vez de un valor truncado.
const port: i32? = parseInt("8080");
const overflowed: i32? = parseInt("9999999999");
const count: u32? = parseInt("-5");
const single: f32? = parseFloat("3.5");Un as T simple preserva el valor o aborta; nunca da la vuelta. Lo que cabe depende de los límites de ambos tipos, y no de su ancho, así que un u32 guarda un valor por encima de i32::MAX mientras que un número negativo nunca cabe en un u32, ni siquiera en uno del mismo ancho.
as T? es un cast falible y sigue la misma regla, salvo que un valor fuera del rango de T se convierte en ausencia en vez de abortar, y así es como un programa se recupera de eso. Un cast de float a entero trunca hacia cero, y NaN produce ausencia.
const wide: i64 = 9999999999;
const narrowed = wide as i32?; // empty, does not fit an i32
const fits = 7 as i32?; // 7
const truncated = parseFloat("2.9") as i32?; // 2
const unbounded = parseFloat("1e30") as i32?; // emptyEl as convierte entre números; nunca reinterpreta un valor como un tipo sin relación. Un enum se lee de vuelta como el primitivo que lo representa, pero nada más cruza: una cadena no es un número, y una interfaz no es otra ni cuando sus campos coinciden. Un valor del tipo objetivo debe ser construido, y afirmarlo en su lugar es un error.
error
interface Loose {
age: i32;
}
interface User {
@min(18)
age: i32;
}
const loose: Loose = { age: 1 };
const user: User = loose as User; error
error[E0605]: cannot convert `Loose` to `User` with `as`: `as` converts, it does not reinterpret: a `Loose` value is not a `User`
at /src/main.tyr:11:20
const user: User = loose as User;
^^^^^
help: build the target value from the source instead of asserting it, or annotate the value with the target type where it is createdEsto importa sobre todo donde el tipo lleva validators. Un User tiene la garantía de satisfacer @min(18), y es esa garantía la que permite al resto del programa saltarse la comprobación. Una conversión que produjera un User sin ejecutar sus validators convertiría la garantía en una mentira, así que se rechaza: construye el User, y maneja el ValidationError que puede lanzar.
Spread y Rest
El operador spread expande arrays y objetos en elementos o campos individuales:
const first: i32[] = [1, 2, 3];
const second: i32[] = [4, 5, 6];
const merged: i32[] = [...first, ...second];
interface Config {
host: string;
port: i32;
}
const base: Config = { host: "localhost", port: 8080 };
const overrides: Partial<Config> = { port: 3000 };
const merged_config: Config = { ...base, ...overrides };Los parámetros rest recogen argumentos trailing en un array:
const log = (level: string, ...messages: string[]): void => {
for (const msg of messages) {
print(`[${level}] ${msg}`); // "[info] server started", "[info] listening on port 3000"
}
};
log("info", "server started", "listening on port 3000");Pertenencia y Ranges
in y not in comprueban si un valor pertenece a un array, un Range, un Map o un Set, reemplazando llamadas a .includes()/!.includes() y .has()/!.has(). not in es la forma negada, escrita con la palabra clave not en vez de un operador separado.
a..b es un Range de a hasta b, excluyendo b; a..=b incluye b. Un range puede anotarse como Range<T>, por ejemplo const ids: Range<i32> = 1..4;. Un Range tiene su propio método .contains(x), x in a..b y (a..b).contains(x) son la misma comprobación.
const permissions: string[] = ["admin", "editor", "dev"];
print("admin" in permissions);
// true
print("guest" not in permissions);
// true
const status: i32 = 204;
print(status in 200..299);
// true
print(status not in 400..=599);
// true
const httpOk = 200..299;
print(httpOk.contains(204));
// truein/not in también conservan su significado original sobre un objeto simple o valor de interfaz: "campo" in obj comprueba si el tipo de obj declara un campo llamado "campo", independiente de la comprobación de pertenencia en array/Range/Map/Set de arriba.
