Operadores e Expressões
Tyrus mantém operadores familiares quando a semântica pode ser checada estaticamente e baixada para código nativo.
Grupos de Operadores
| Categoria | Operadores |
|---|---|
| Aritméticos | + - * / % ** |
| Unários | - + ++ -- ! not ~ |
| Bitwise | & | ^ ~ << >> >>> |
| Comparação | > < >= <= === !== |
| Lógicos | && and || or |
| Ternário | ? : |
| Atribuição | = += -= *= /= %= **= &= |= ^= <<= >>= >>>= &&= ||= ??= |
| Null safety | ?? ?. |
| Borrow | & &mut |
| Pertencimento | in not in |
| Checagem de tipo | is not is |
| Range | .. ..= |
and, or e not são equivalentes escritos exatos de &&, || e !, o lexer mapeia cada par para o mesmo token, então as duas grafias podem se misturar livremente na mesma expressão: active and not suspended or isAdmin e active && !suspended || isAdmin compilam de forma idêntica.
Comparações Encadeadas
Três ou mais de <, <=, >, >=, === encadeados diretamente (a < b < c) são açúcar sintático para a < b && b < c, lendo mais perto da notação algébrica do que o equivalente escrito com &&.
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 termo na cadeia é avaliado exatamente uma vez, mesmo quando participa de duas comparações, um termo com efeito colateral (uma chamada de função) nunca roda duas vezes. A cadeia também faz curto-circuito como o &&: assim que uma comparação falha, os termos seguintes nunca são avaliados. Dois termos (a < b) não são afetados por esse açúcar e continuam sendo uma comparação simples; a cadeia só entra a partir de três termos. !== nunca encadeia, não existe leitura algébrica para a != b != c, então sempre permanece uma comparação simples de dois termos.
Pipeline
Consulte o guia do operador pipe para conhecer o operador |>, o token de topic % e a composição de pipelines.
Ternário
const label: string = score >= 90 ? "A" : "B";A condição ternária deve ser boolean e os dois branches devem ter o mesmo tipo.
typeof
O operador typeof retorna uma string com o nome do tipo tyrus do valor em runtime: o nome do próprio tipo, não uma categoria genérica. Os tipos numéricos continuam distintos em vez de colapsar em "number", um array informa o tipo do elemento, uma interface informa o próprio nome e um opcional mantém o ?. Só duas formas respondem com uma categoria, por não terem nome a dar: um tipo de objeto anônimo ("object") e uma função ("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 também pode ser usado como type query.
const count: i32 = 42;
type CountType = typeof count;
const other: CountType = 7;Comparações com typeof fazem narrowing de valores union no fluxo de controle.
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
}
}Isto também funciona com enums, typeof retorna a representação subjacente:
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
O operador is verifica se um valor em runtime corresponde a um tipo específico dentro de uma union, retornando boolean. Ele é o 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 do branch true, o compilador estreita value para string. Fora dele, value permanece string | number.
not is é a 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 também funcionam em condições de while e atribuições booleanas. A checagem roda em runtime comparando a tag de tipo da union contra o tipo alvo.
Um erro capturado mantém o tipo com que foi lançado, então is também distingue erros. Em catch (error), error is ConfigError é true quando o valor lançado era um ConfigError (um erro de módulo como FsError, ou uma interface que estende Error), e dentro desse branch error tem todos os campos do subtipo. Um catch (error: A | B) estreita para a variante do mesmo jeito. Isso vale também numa função async, inclusive para um erro que chega como rejeição de um await, e num catch (error) que aguarda antes da checagem. Só um Error que não veio de um catch não consegue distinguir o subtipo (E3297). Um handler que confere os erros que conhece termina com throw error; para o resto: o valor segue com o seu subtipo, então o próximo catch ainda o distingue, e um tipo de erro acrescentado depois é repassado em vez de silenciado.
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;Uma assertion numérica preserva o valor ou aborta; ela nunca wrappa. As checagens rodam em todos os perfis, então uma execução em debug prevê o que o binário publicado faz. Assertions non-primitive são casts de identidade e devem ser usadas com cuidado.
Conversão e 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 opcionais em vez de NaN, preservando null safety.
A anotação escolhe a largura do parse, com a largura escolhida pela anotação. parseInt estreita para qualquer tipo inteiro e parseFloat/Number para f32 ou f64; sem anotação, permanecem i64? e f64?. Um texto cujo valor não cabe no tipo alvo simplesmente não parseia como aquele tipo, então o resultado é ausência em vez de um valor truncado.
const port: i32? = parseInt("8080");
const overflowed: i32? = parseInt("9999999999");
const count: u32? = parseInt("-5");
const single: f32? = parseFloat("3.5");Um as T simples preserva o valor ou aborta; ele nunca dá a volta. O que cabe depende dos limites dos dois tipos, e não da largura deles, então um u32 guarda um valor acima de i32::MAX enquanto um número negativo nunca cabe num u32, nem mesmo num da mesma largura.
as T? é um cast falível e segue a mesma regra, exceto que um valor fora do intervalo de T vira ausência em vez de abortar, e é assim que um programa se recupera disso. Um cast de float para inteiro trunca em direção ao zero, e NaN produz ausência.
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?; // emptyO as converte entre números; ele nunca reinterpreta um valor como um tipo sem relação. Um enum é lido de volta como o primitivo que o representa, mas nada além disso atravessa: uma string não é um número, e uma interface não é outra nem quando os campos coincidem. Um valor do tipo alvo precisa ser construído, e afirmá-lo no lugar disso é um erro.
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 createdIsto importa sobretudo onde o tipo carrega validators. Um User tem a garantia de satisfazer @min(18), e é essa garantia que permite ao resto do programa dispensar a checagem. Uma conversão que produzisse um User sem rodar os validators dele tornaria a garantia uma mentira, então ela é rejeitada: construa o User, e trate o ValidationError que ele pode lançar.
Spread e Rest
O operador spread expande arrays e objetos em elementos ou campos individuais:
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 };Parâmetros rest coletam argumentos finais em um 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");Pertencimento e Ranges
in e not in checam se um valor pertence a um array, um Range, um Map ou um Set, substituindo chamadas a .includes()/!.includes() e .has()/!.has(). not in é a forma negada, escrita com a palavra-chave not em vez de um operador separado.
a..b é um Range de a até b, excluindo b; a..=b inclui b. Um range pode ser anotado como Range<T>, como em const ids: Range<i32> = 1..4;. Um Range tem seu próprio método .contains(x), x in a..b e (a..b).contains(x) são a mesma checagem.
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 também mantêm seu significado original sobre um objeto simples ou valor de interface: "campo" in obj checa se o tipo de obj declara um campo chamado "campo", independente da checagem de pertencimento em array/Range/Map/Set acima.
