Skip to content

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 ​

CategoriaOperadores
Aritméticos+ - * / % **
Unários- + ++ -- ! not ~
Bitwise& | ^ ~ << >> >>>
Comparação> < >= <= === !==
Lógicos&& and || or
Ternário? :
Atribuição= += -= *= /= %= **= &= |= ^= <<= >>= >>>= &&= ||= ??=
Null safety?? ?.
Borrow& &mut
Pertencimentoin not in
Checagem de tipois 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 &&.

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

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

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

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

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

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

tyrus
enum Status: string {
    Active = "active",
    Inactive = "inactive",
}

const current: Status = Status.Active;
const kind: string = typeof current; // "string", the enum's backing type

is / 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.

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

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

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

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

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

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

tyrus
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?;   // empty

O 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

tyrus
interface Loose {
    age: i32;
}

interface User {
    @min(18)
    age: i32;
}

const loose: Loose = { age: 1 };
const user: User = loose as User;   

error

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

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

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

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

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

in/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.