Skip to content

Objetos e Interfaces ​

Tyrus usa sintaxe concisa para objetos, e interfaces nomeadas e aliases de objeto fazem lowering para layouts de struct nativos.

Interfaces ​

tyrus
interface User {
    readonly id: i32;
    name: string;
    nickname?: string;
    active: boolean;
}

const user: User = {
    id: 1,
    name: "Ada",
    active: true,
};

const renamed: User = {
    ...user,
    name: "Grace",
};

const active: boolean = true;
const shorthand: User = { id: 2, name: "Grace", active };

readonly impede reatribuição do campo. Campos opcionais leem como T? e devem ser tratados com narrowing ou ??. Literais de objeto são checados para campos ausentes, extras e com tipo incorreto. Object spread cria updates imutáveis com o mesmo layout de interface do objeto de origem. Quando o valor de um campo é uma variável local com o mesmo nome, escreva o nome uma única vez, { active } é açúcar sintático para { active: active }, e combina livremente com campos explícitos key: value e com um spread update.

Métodos automáticos de dados ​

Toda interface de dados nomeada recebe métodos automáticos de dados sem anotações nem declarações. Os quatro primeiros são chamadas de instância comuns, e fromJson é uma chamada estática no nome concreto da interface. Uma interface de comportamento pode definir um método de instância com o mesmo nome e tem precedência sobre o método automático.

copy() ​

Cria uma cópia estrutural independente.

copy() não é só para objetos: existe em todo valor que possui um buffer, ou seja, todo tipo que não é Copy. Isso cobre string, arrays, tuplas e os opcionais, results e uniões construídos a partir deles. Num escalar Copy como i32 o método não existe, porque let a = b já duplica e um método sugeriria que outra coisa acontece.

O resultado é um valor comum do próprio tipo. Uma decoration pertence ao campo de onde o valor foi lido, não ao valor, então nada da declaração de origem acompanha a cópia.

Ler um campo para um binding do mesmo tipo o move: const items = order.items; entrega o campo a items, order continua utilizável pelos outros campos, e ler order.items ou order inteiro depois é recusado (E0382) até o campo ser atribuído de novo. Onde o move não pode acontecer, o compilador sugere copy(): quando os campos do dono têm validators, cujas regras descrevem o valor inteiro, quando o campo é alcançado por uma referência, ou quando o binding é declarado com um tipo diferente do campo, como um string lido de um string? estreitado (E3081). order.items.copy() diz o que faz e mantém o custo visível, o que uma cópia inserida em silêncio não faria.

tyrus
interface User { name: string; }

const user: User = { name: "Ada" };
const copied: User = user.copy();
print(copied); // { name: "Ada" }

equals(other: Type) ​

Compara campos elegíveis estruturalmente, inclusive campos opcionais ausentes e presentes. Arrays não são elegíveis porque sua igualdade é por endereço. O argumento precisa ter a mesma interface nominal.

tyrus
interface User { name: string; }

const first: User = { name: "Ada" };
const second: User = { name: "Ada" };
const same: boolean = first.equals(second); // true

Uma interface com campos correspondentes ainda não pode ser passada para equals() quando tiver outro nome:

error

tyrus
interface User { name: string; }
interface OtherUser { name: string; }

const main = (): void => {
    const user: User = { name: "Ada" };
    const other: OtherUser = { name: "Ada" };
    const same: boolean = user.equals(other); 
    print(same);
};
text
error[E0308]: `OtherUser` is not assignable to `User`: tyrus interfaces are nominal, so distinct interface names are separate types even with the same fields; build a `User` value directly (its fields are available on `OtherUser`), or use one shared interface type for both
at /src/main.tyr:7:27
    const same: boolean = user.equals(other);
                          ^^^^^^^^^^^^^^^^^^
help: change the value or the annotation so their types match; convert numbers explicitly with `value as <type>`

toString() ​

Produz uma representação legível na ordem declarada dos campos, coloca aspas e escapes nas strings, mostra campos opcionais ausentes como None e renderiza valores aninhados recursivamente.

tyrus
interface User { name: string; nickname?: string; }

const user: User = { name: "Ada" };
const text: string = user.toString(); // "{ name: \"Ada\", nickname: None }"

toJson(options?: { pretty: boolean }) ​

Emite JSON canônico com espaço após cada dois-pontos. Passe { pretty: true } para JSON em múltiplas linhas com indentação de quatro espaços. As chaves saem em ordem alfabética, não na ordem de declaração, para que o mesmo dado produza sempre o mesmo texto: acrescentar um campo depois não move os que já estavam lá. Um decimal é escrito em notação comum, o mesmo texto com que ele é impresso: 12.50d sai como 12.5, com todos os dígitos preservados e sem arredondamento.

tyrus
interface User { 
  name: string; 
  scores: i32[]; 
}

const user: User = { name: "Ada", scores: [10, 20] };
const json: string = user.toJson();
const pretty: string = user.toJson({
    pretty: true,
});

print(json); // {"name": "Ada","scores": [10,20]}
print(pretty);
/*
{
    "name": "Ada",
    "scores": [
        10,
        20
    ]
}
*/

Um campo que carrega uma união discriminada é escrito como o objeto que a variante viva já é: não há envelope, e o campo discriminante é o que diz ao leitor qual variante ele recebeu. O fromJson lê de volta do mesmo jeito, escolhendo a variante pelo discriminante; um discriminante que não nomeia nenhuma variante declarada é recusado com ERR_JSON_UNKNOWN_VARIANT em vez de adivinhado, que é justamente para isso que ele é escrito.

tyrus
interface Job {
    id: i32;
    state: { kind: "done"; value: i32 } | { kind: "failed"; reason: string };
}

const done: Job = { id: 1, state: { kind: "done", value: 42 } };
console.log(done.toJson());
// {"id": 1,"state": {"kind": "done","value": 42}}

const failed: Job = { id: 2, state: { kind: "failed", reason: "timeout" } };
console.log(failed.toJson());
// {"id": 2,"state": {"kind": "failed","reason": "timeout"}}

Type.fromJson(text: string) ​

Valida sintaxe, campos, tipos e faixas numéricas, retornando JsonError com code estável, message legível e path do campo em vez de lançar.

Signatureinterface JsonError { readonly code: string; readonly message: string; readonly path: string; }
tyrus
interface User { name: string; }

const result: Result<User, JsonError> = User.fromJson("{\"name\":\"Ada\"}");
match (result) {
    Ok(user) => {
        print(user.name); // Ada
    }
    Err(error) => {
        printError(error.code);
    }
}

Use onfail para imprimir um JsonError e encerrar a função void atual quando a decodificação falhar:

error

tyrus
interface User { name: string; }

function main(): void {
    const json = User.fromJson("{\"name\":123}") onfail {
        print(json.code); // ERR_JSON_TYPE_MISMATCH
        print(json.message); // JSON field does not match the declared type
        print(json.path); // name
    };

    print(json.name); //
}

Interfaces de comportamento com at ​

Interfaces de comportamento anexam métodos executáveis a um ou mais tipos receptores com at. O receptor é o primeiro parâmetro explícito, então o método continua sendo comum e a chamada usa a sintaxe value.method(). Quando sua anotação é omitida para múltiplos alvos, o compilador especializa e verifica a implementação separadamente para cada alvo. Uma interface de comportamento contém métodos ou shorthand bindings, não campos de dados.

tyrus
interface User {
    age: u32;
}

interface UserMethods at User {
    isAdult(user: User): boolean {
        return user.age >= 18;
    }
}

const user: User = { age: 21 };
const adult: boolean = user.isAdult(); // true
tyrus
// model.tyr
export interface User { age: u32; }
export const ageText = (user: User): string => user.age.toString();
export interface UserMethods at User { ageText; }

// main.tyr
import { User, UserMethods } from "./model";
const user: User = { age: 21 };
const text: string = user.ageText(); // "21"
tyrus
interface NumberMethods at i32 {
    isPositive(value: i32): boolean {
        return value > 0;
    }
}

interface StringMethods at string {
    isBlank(value: string): boolean {
        return value.length === 0;
    }
}

interface BooleanMethods at boolean {
    inverted(value: boolean): boolean {
        return !value;
    }
}

interface CharMethods at char {
    isAscii(value: char): boolean {
        return value.isAlphabetic();
    }
}

const number: i32 = 4;
const text: string = "";
const enabled: boolean = true;
const letter: char = 'A';
const positive: boolean = number.isPositive(); // true
const blank: boolean = text.isBlank(); // true
const inverted: boolean = enabled.inverted(); // false
const ascii: boolean = letter.isAscii(); // true
tyrus
interface PositiveNumbers at i32, u32 {
    isPositive(value): boolean {
        return value > 0;
    }
}

const signed: i32 = 7;
const unsigned: u32 = 9;
const signedPositive: boolean = signed.isPositive(); // true
const unsignedPositive: boolean = unsigned.isPositive(); // true

Shorthand bindings nomeiam funções declaradas no mesmo módulo ou importadas de outro módulo. As assinaturas são checadas quando o comportamento é declarado, e a assinatura importada é preservada entre módulos para a checagem de tipos e a geração de código nativo. Interfaces de comportamento também podem usar extend para herdar métodos de outras interfaces de comportamento.

O receptor de at pode ser uma interface nomeada ou um tipo primitivo. A mesma sintaxe de chamada por membro funciona para valores numéricos, strings, booleanos e chars.

Acesso a propriedade por nome ​

Um campo é lido e escrito com a forma de ponto e com um literal de string entre colchetes, os dois são o mesmo acesso: a chave está escrita no código, então ela nomeia um campo que o compilador conhece, e ambos compilam para o mesmo offset fixo.

tyrus
interface Person {
    name: string;
    age: i32;
}

let person: Person = { name: "Ada", age: 36 };

print(person.name);
print(person["name"]);

person["age"] = 42;

Só um literal se qualifica. person[chave], com chave sendo uma variável, é erro de compilação (E0608): uma interface tem um conjunto fixo de campos e nenhuma busca em tempo de execução para onde recorrer. Um literal que não nomeia campo nenhum é E0609, reportado com o nome. Para chaves decididas em tempo de execução, use Record<string, T>, que é um hash map de verdade, lookup["a"] ali é uma busca que pode falhar, então devolve T?.

Atribuição de campo ​

Um campo pode ser atribuído no lugar com object.field = value, incluindo as formas compostas como +=, através de receptores aninhados e em elementos indexados.

tyrus
interface Point {
    x: i64;
    y: i64;
}

let point: Point = { x: 1, y: 2 };
point.x = 10;
point.y += 5;

A atribuição no lugar exige um binding mutável: um binding const é profundamente imutável, e um campo readonly ou um valor de um tipo readonly rejeita a escrita. A atribuição no lugar hoje funciona para campos de número, booleano e char; para trocar um campo string, um array ou um objeto aninhado, construa um novo valor com object spread.

Herança de Interface ​

Uma interface pode extend uma ou mais outras interfaces para herdar seus campos. A interface filha exige todos os campos herdados mais os próprios, então um valor do tipo filho precisa fornecer todos eles. A herança só faz merge de campos, ela não torna a filha atribuível à pai (veja o layout nominal abaixo).

tyrus
interface Age {
    age: u32;
}

interface Person extends Age {
    name: string;
}

// `Person` requires both the inherited `age` and its own `name`.
const person: Person = { age: 30, name: "Ada" };

// An interface that extends another and adds nothing has just the inherited
// fields.
interface JustAge extends Age {}
const onlyAge: JustAge = { age: 25 };

Interseção de Tipos ​

Um alias type combina tipos de objeto com &. O alias exige todos os campos de todos os operandos, exatamente como a herança faz, e cada operando é uma interface nomeada ou um objeto escrito inline. O & é a forma do alias para o que o extend faz numa interface: interface herda com extend, type combina com &.

tyrus
interface Age {
    age: u32;
}

interface Contact {
    email: string;
}

// `&` combines object types into one named type.
type Person = Age & Contact;
const person: Person = { age: 30, email: "[email protected]" };

// An operand can be written inline, anywhere in the chain.
type Employee = { title: string; } & Age & Contact;
const employee: Employee = { title: "Engineer", age: 41, email: "[email protected]" };

Quando dois operandos declaram o mesmo campo com tipos diferentes, o alias é recusado onde está escrito (E3214) em vez de produzir um campo que nenhum valor consegue satisfazer.

error

tyrus
interface Metric {
    value: i32;
}

interface Label {
    value: string;
}

type Mixed = Metric & Label; 

O & pertence a um alias type e a mais nenhum lugar. Ele não é aceito numa anotação de tipo (E3215): nomeie a interseção primeiro e depois use o nome.

error

tyrus
interface Age {
    age: u32;
}

interface Contact {
    email: string;
}

function greet(person: Age & Contact): void { 
    print(person.email);
}

Todo operando precisa ser um tipo de objeto. Um operando que seja um primitivo, um array, uma união ou uma função é recusado com E3213, e um alias que se refere a si mesmo pela cadeia é recusado com E3216. Misturar & e | no mesmo alias é recusado com E3217, um diagnóstico próprio porque o motivo é a precedência: o | liga mais forte, então type A = B & C | D; seria lido como B & (C | D). Só parênteses não resolvem, já que uma união nunca é um operando válido. Nomeie a interseção e use esse nome na união: type BC = B & C; e depois type A = BC | D;.

Layout Nativo Nominal ​

No tyrus não trata todo formato de objeto compatível como intercambiável. Interfaces são tipos produto nativos nomeados, então passar um CompleteUser onde SummaryUser é esperado exige um objeto de conversão explícito.

tyrus
interface SummaryUser {
    id: i32;
}

interface CompleteUser {
    id: i32;
    name: string;
}

const complete: CompleteUser = { id: 99, name: "TitenQ" };
const summary: SummaryUser = { id: complete.id };

Para guardar valores de várias formas numa mesma coleção, use uma tagged union com um campo discriminante literal e match em vez de uma interface base compartilhada, ela preserva os campos de cada variante e mantém a exaustividade:

tyrus
type User =
    | { kind: "admin"; name: string; permissions: string }
    | { kind: "guest"; name: string; expiresAt: i64 };

const nameOf = (user: User): string => {
    match (user) {
        ({ kind: "admin", name }) => { return name; }
        ({ kind: "guest", name }) => { return name; }
    }
    return "";
};

const users: User[] = [
    { kind: "admin", name: "Ada", permissions: "root" },
    { kind: "guest", name: "Bob", expiresAt: 999 },
];

Ordem de Armazenamento dos Campos ​

Os campos são armazenados na ordem que desperdiça menos espaço, que nem sempre é a ordem em que foram escritos: um campo largo é posto à frente de um estreito para que o vão que o estreito deixaria antes dele desapareça. A interface abaixo ocupa 40 bytes escrita assim e 24 bytes armazenada, e guardar um milhão delas é a diferença entre 40 MB e 24 MB.

tyrus
interface Reading {
    ok: boolean;
    id: i64;
    scale: u8;
    value: f64;
    stale: boolean;
    sequence: i32;
}

const reading: Reading = {
    ok: true,
    id: 900000000001,
    scale: 4,
    value: 2.5,
    stale: false,
    sequence: 77,
};

Nada muda no uso da interface: os campos são lidos, escritos, espalhados e desestruturados por nome, um literal de objeto continua avaliando seus campos na ordem em que os lista, e imprimir um valor continua mostrando os campos na ordem em que a interface os declara. A ordem é uma decisão de armazenamento e nunca é observável a partir do programa.

Type Aliases ​

tyrus
type Point = {
    x: i32;
    y: i32;
};

Para formatos de objeto, type e interface são equivalentes no layout nativo. Um alias type também pode nomear unions, tuplas, tipos de função e utility types.

Utilitários de Tipo ​

CategoriaUtilities
Transformação de objetoPartial<T>, Optional<T, K>, Required<T>, Readonly<T>, DeepPartial<T>
Seleção de chavesPick<T, K>, Omit<T, K>
Seleção por tipoPickByType<T, Type>, OmitByType<T, Type>
Renomeação de chavesCamelCaseKeys<T>, SnakeCaseKeys<T>
Controle de camposRequire<T, K>, AtLeastOne<T, K>
Extração de dadosDataOnly<T>
Mapeamento chave/valorkeyof, Record<K, T>
Tipos de funçãoReturnType<T>, Parameters<T>
Manipulação de unionExclude<T, U>, Extract<T, U>
Tipos condicionaisT extends U ? X : Y, infer R

Transformação de objeto ​

Partial<T> ​

Torna todo campo opcional, quem chama pode fornecer qualquer subconjunto.

AssinaturaPartial<T> = { [K in keyof T]?: T[K] }
tyrus
interface Account {
    id: i32;
    email: string;
    active: boolean;
}

type AccountPatch = Partial<Account>;
const patch: AccountPatch = { email: "[email protected]" };

error

tyrus
interface Account {
    id: i32;
    email: string;
    active: boolean;
}

type AccountPatch = Partial<Account>;
const patch: AccountPatch = { email: 42 }; 
text
error[E0308]: type mismatch for `email`: expected `string?`, found `42`
at /src/main.tyr:8:31
const patch: AccountPatch = { email: 42 };
                              ^^^^^
help: change the value or the annotation so their types match; convert numbers explicitly with `value as <type>`

Optional<T, K> ​

Mantém todos os campos e torna opcionais somente as chaves selecionadas. A forma existente com um argumento, Optional<T>, continua sendo a grafia de T?.

AssinaturaOptional<T, K extends keyof T> = { [P in keyof T]: P extends K ? T[P]? : T[P] }
tyrus
interface User {
    id: i32;
    name: string;
    email?: string;
    password: string;
}

type Update = Optional<User, "name" | "email">;
const update: Update = { id: 1, password: "rotated" };

const user: User = { id: 1, name: "Ada", password: "secret" };
const publicUser = user.pick(["id", "name"]);
const storedUser = user.omit(["password"]);

print(publicUser.name);
print(storedUser.id);

Required<T> ​

Torna todo campo opcional em obrigatório, todos os campos devem ser fornecidos.

AssinaturaRequired<T> = { [K in keyof T]-?: T[K] }
tyrus
interface Config {
    host?: string;
    port?: i32;
}

type StrictConfig = Required<Config>;
const cfg: StrictConfig = { host: "localhost", port: 8080 };

error

tyrus
interface Config {
    host?: string;
    port?: i32;
}

type StrictConfig = Required<Config>;
const cfg: StrictConfig = { host: "localhost" }; 
text
error[E2741]: property `port` is missing in object literal for type `object`
at /src/main.tyr:7:7
const cfg: StrictConfig = { host: "localhost" };
      ^^^

Readonly<T> ​

Impede a reatribuição de campos, o objeto inteiro se torna profundamente imutável. É um dos seis lugares em que a palavra-chave aparece; a página Readonly cobre todos eles.

AssinaturaReadonly<T> = { readonly [K in keyof T]: Readonly<T[K]> }
tyrus
interface Endpoint {
    port: i32;
}

interface Config {
    endpoint: Endpoint;
    name: string;
}

type Frozen = Readonly<Config>;

export function main(): void {
    let config: Frozen = { endpoint: { port: 8080 }, name: "api" };
    print(config.endpoint.port);
}

error

tyrus
let config: Frozen = { endpoint: { port: 8080 }, name: "api" };
config.name = "web"; 
text
error[E2542]: cannot assign to readonly property `name`
at /src/main.tyr:18:1
config.name = "web";
^^^^^^^^^^^^^^^^^^^^

The guarantee reaches every level, not only the surface. A nested object is frozen too:

error

tyrus
let config: Frozen = { endpoint: { port: 8080 }, name: "api" };
config.endpoint.port = 9090; 
text
error[E2541]: cannot assign to `port` through a readonly value
at /src/main.tyr:18:1
config.endpoint.port = 9090;
^^^^^^^^^^^^^^^^^^^^^^^^^^^^

An array field becomes a readonly array, so its mutating methods are refused as well:

error

tyrus
interface Tagged {
    tags: string[];
}

let tagged: Readonly<Tagged> = { tags: ["a"] };
tagged.tags.push("b"); 
text
error[E2540]: cannot call mutating method `push` on readonly array
at /src/main.tyr:6:1
tagged.tags.push("b");
^^^^^^^^^^^

Deeply recursive

Readonly<T> applies recursively to nested objects and arrays, so values cannot be mutated through a nested property.

The examples above use let. With const the binding is already deeply immutable on its own, so the rejection would come from the binding rather than from the type, and would not show what Readonly<T> adds.

DeepPartial<T> ​

Torna todo campo opcional recursivamente, até 5 níveis de profundidade. Ideal para payloads de atualização parcial (PATCH).

AssinaturaDeepPartial<T> = { [K in keyof T]?: DeepPartial<T[K]> }
tyrus
interface Config {
    db: {
        host: string;
        port: i32;
    };
    active: boolean;
}

type ConfigPatch = DeepPartial<Config>;
const patch: ConfigPatch = {
    db: {
        host: "localhost"
    }
};

error

tyrus
interface Config {
    db: {
        host: string;
        port: i32;
    };
    active: boolean;
}

type ConfigPatch = DeepPartial<Config>;
const bad: ConfigPatch = { db: { host: 42 } }; 
text
error[E0308]: type mismatch for `db`: expected `{ host?: string; port?: i32 }?`, found `object`
at /src/main.tyr:10:28
const bad: ConfigPatch = { db: { host: 42 } };
                           ^^
help: change the value or the annotation so their types match; convert numbers explicitly with `value as <type>`

Seleção de chaves ​

Pick<T, K> ​

Seleciona um subconjunto de campos por chave, o resultado tem apenas as chaves listadas.

AssinaturaPick<T, K extends keyof T> = { [P in K]: T[P] }
tyrus
interface User {
    id: i32;
    name: string;
    email: string;
    role: string;
}

type UserSummary = Pick<User, "id" | "name">;
const summary: UserSummary = { id: 1, name: "Ada" };

error

tyrus
interface User {
    id: i32;
    name: string;
    email: string;
}

type Bad = Pick<User, "id" | "missing">; 
text
error[utility-unknown-key]: `missing` is not a property of the type given to `Pick`
at /src/main.tyr:1:1
interface User {
^

Omit<T, K> ​

Remove um subconjunto de campos por chave, o resultado tem tudo exceto as chaves listadas.

AssinaturaOmit<T, K extends keyof T> = { [P in Exclude<keyof T, K>]: T[P] }
tyrus
interface User {
    id: i32;
    name: string;
    email: string;
}

type PublicUser = Omit<User, "email">;
const pub: PublicUser = { id: 1, name: "Ada" };
tyrus
interface User {
    id: i32;
    name: string;
    email: string;
}

type PublicUser = Omit<User, "email">;
const email = pub.email; 
text
error[E0411]: field `email` does not exist on `PublicUser`
  --> src/main.tyr:6:21
   |
 6 | const email = pub.email;
   |                     ^^^^^ field `email` was omitted from the original type
   |
help: use the original `User` type if `email` is needed

Projeções de valor ​

value.pick(keys) e value.omit(keys) criam um novo objeto com os campos selecionados ou restantes. As chaves precisam ser conhecidas em compilação, em um array literal ou em uma variável com tipo finito de chaves literais. O receptor não é mutado, a ordem dos campos segue o tipo de origem e não há busca de chave em runtime.

tyrus
interface User {
    id: i32;
    name: string;
    email?: string;
    password: string;
}

type Update = Optional<User, "name" | "email">;
const update: Update = { id: 1, password: "rotated" };

const user: User = { id: 1, name: "Ada", password: "secret" };
const publicUser = user.pick(["id", "name"]);
const storedUser = user.omit(["password"]);

print(publicUser.name);
print(storedUser.id);

Seleção por tipo ​

PickByType<T, Type> ​

Seleciona campos pelo tipo do valor, mantém apenas os campos cujo tipo corresponde a Type.

AssinaturaPickByType<T, Type> = { [K in keyof T as T[K] extends Type ? K : never]: T[K] }
tyrus
interface User {
    id: i32;
    name: string;
    email: string;
    active: boolean;
}

type UserStrings = PickByType<User, string>;
const preview: UserStrings = { name: "Ada", email: "[email protected]" };

error

tyrus
interface User {
    id: i32;
    name: string;
    email: string;
}

type UserId = PickByType<User, i32>;
const bad: UserId = { name: "Ada" }; 
text
error[E2353]: object literal specifies unknown property `name`
at /src/main.tyr:8:23
const bad: UserId = { name: "Ada" };
                      ^^^^

OmitByType<T, Type> ​

Remove campos pelo tipo do valor, exclui todos os campos cujo tipo corresponde a Type.

AssinaturaOmitByType<T, Type> = { [K in keyof T as T[K] extends Type ? never : K]: T[K] }
tyrus
interface Product {
    id: i32;
    name: string;
    price: f64;
    inStock: boolean;
}

type NonNumeric = OmitByType<Product, i32>;
const listing: NonNumeric = { name: "Widget", price: 29.99, inStock: true };

error

tyrus
interface User {
    id: i32;
    name: string;
    email: string;
}

type UserData = OmitByType<User, string>;
const bad: UserData = { name: "Ada" }; 
text
error[E2353]: object literal specifies unknown property `name`
at /src/main.tyr:8:25
const bad: UserData = { name: "Ada" };
                        ^^^^

Mapeamento chave/valor ​

keyof ​

Extrai as chaves de um tipo como uma union literal de string.

Assinaturakeyof T = string literal union of T's keys
tyrus
interface Account {
    id: i32;
    email: string;
}

type Key = keyof Account;
const k: Key = "id";

error

tyrus
interface Account {
    id: i32;
    email: string;
}

type Key = keyof Account;
const k: Key = "missing"; 
text
error[E0308]: type mismatch for `k`: expected `"id" | "email"`, found `string`
at /src/main.tyr:7:7
const k: Key = "missing";
      ^
help: change the value or the annotation so their types match; convert numbers explicitly with `value as <type>`

Record<K, T> ​

Record<K, T> é um tipo utilitário embutido, como Pick<T, K> e Omit<T, K>. O compilador o resolve e ele não cria uma classe Record em runtime. Quando K é uma união finita de chaves string literais, o Tyrus produz um tipo objeto com um campo obrigatório por chave. Quando K é aberto, como string, o Tyrus o resolve para Map<K, T>, adequado a chaves dinâmicas.

AssinaturaRecord<K extends string, T> = campos obrigatórios de objeto para K literal finito; Map<K, T> para K aberto
tyrus
type Roles = Record<"admin" | "user", boolean>;
const perms: Roles = { admin: true, user: false };

error

tyrus
type Roles = Record<"admin" | "user", boolean>;
const perms: Roles = { admin: true }; 
text
error[E2741]: property `user` is missing in object literal for type `object`
at /src/main.tyr:2:7
const perms: Roles = { admin: true };
      ^^^^^

For an open key type, Record<string, T> resolves to Map<string, T>, so lookups may be absent and map methods are available:

tyrus
let inventory: Record<string, i32> = { apples: 3, pears: 5 };
inventory["bananas"] = 12;
const apples: i32 = inventory.get("apples") ?? 0;
const hasPears: boolean = inventory.has("pears");

Renomeação de chaves ​

CamelCaseKeys<T> ​

Transforma todos os nomes de campo de snake_case para camelCase. Essencial para integrações com APIs externas.

AssinaturaCamelCaseKeys<T> = { [K in camelCase<keyof T>]: T[snake_case<K>] }
tyrus
interface ApiUser {
    user_id: i32;
    first_name: string;
    is_active: boolean;
}

type User = CamelCaseKeys<ApiUser>;
const user: User = { userId: 1, firstName: "Ada", isActive: true };

error

tyrus
interface Config {
    db_host: string;
    db_port: i32;
}

type Cfg = CamelCaseKeys<Config>;
const bad: Cfg = { db_host: "localhost", db_port: 5432 }; 
text
error[E2353]: object literal specifies unknown property `db_host`
at /src/main.tyr:7:20
const bad: Cfg = { db_host: "localhost", db_port: 5432 };
                   ^^^^^^^

SnakeCaseKeys<T> ​

Transforma todos os nomes de campo de camelCase para snake_case. Útil para payloads de APIs legadas e bancos de dados.

AssinaturaSnakeCaseKeys<T> = { [K in snake_case<keyof T>]: T[camelCase<K>] }
tyrus
interface User {
    userId: i32;
    firstName: string;
    isActive: boolean;
}

type UserDb = SnakeCaseKeys<User>;
const row: UserDb = { user_id: 1, first_name: "Ada", is_active: true };

error

tyrus
interface ApiConfig {
    dbHost: string;
    dbPort: i32;
}

type Legacy = SnakeCaseKeys<ApiConfig>;
const bad: Legacy = { dbHost: "localhost", dbPort: 5432 }; 
text
error[E2353]: object literal specifies unknown property `dbHost`
at /src/main.tyr:7:23
const bad: Legacy = { dbHost: "localhost", dbPort: 5432 };
                      ^^^^^^

Tipos de função ​

ReturnType<T> ​

Infere o tipo de retorno de um tipo função, extrai o que a função produz.

AssinaturaReturnType<T extends (...args: any) => any> = T's return type
tyrus
type Fn = (i32) => string;
type Result = ReturnType<Fn>; // string

error

tyrus
type NotFn = i32;
type Bad = ReturnType<NotFn>; 
text
error[utility-non-function]: `ReturnType` requires a function type, found `i32`
at /src/main.tyr:1:1
type NotFn = i32;
^

Parameters<T> ​

Infere os tipos dos parâmetros de um tipo função como tupla, extrai o que a função espera.

AssinaturaParameters<T extends (...args: any) => any> = T's parameter tuple
tyrus
type Fn = (i32, string) => boolean;
type Params = Parameters<Fn>;

error

tyrus
type NotFn = i32;
type Bad = Parameters<NotFn>; 
text
error[utility-non-function]: `Parameters` requires a function type, found `i32`
at /src/main.tyr:1:1
type NotFn = i32;
^

Controle de campos ​

Require<T, K> ​

Torna campos específicos obrigatórios. É um noop se o campo já for obrigatório.

AssinaturaRequire<T, K extends keyof T> = T & { [P in K]-?: T[P] }
tyrus
interface Client {
    id: i32;
    name: string;
    email?: string;
    phone?: string;
}

type ClientWithEmail = Require<Client, "email">;
const client: ClientWithEmail = { id: 1, name: "Ada", email: "[email protected]" };

error

tyrus
interface User {
    id: i32;
    name: string;
    email: string;
}

type Strict = Partial<User> & Require<User, "id">;
const bad: Strict = { name: "Ada" }; 
text
error[E0401]: missing required field `id`
  --> src/main.tyr:7:24
   |
 7 | const bad: Strict = { name: "Ada" };
   |                        ^^^^^^^^^^^^^^ field `id` is required by `Require<User, "id">`
   |
help: add `id` to the object literal

AtLeastOne<T, K> ​

Torna todos os campos especificados opcionais mas exige que pelo menos um deles esteja presente. Cada chave em K deve ser uma propriedade de T.

AssinaturaAtLeastOne<T, K extends keyof T> = { [P in keyof T]: P extends K ? T[P]? : T[P] }
tyrus
interface Form {
    name: string;
    email?: string;
    phone?: string;
}

type ContactForm = AtLeastOne<Form, "email" | "phone">;
const formA: ContactForm = { name: "Ada", email: "[email protected]" };
const formB: ContactForm = { name: "Ada", phone: "555-1234" };

error

tyrus
interface User {
    id: i32;
    name: string;
    email: string;
}

type Lookup = AtLeastOne<User, "name" | "email">;
const bad: Lookup = { id: 1 }; 
text
error[E0308]: type mismatch for `bad`: expected `{ id: i32; name: string; email?: string } | { id: i32; name?: string; email: string }`, found `object`
at /src/main.tyr:8:7
const bad: Lookup = { id: 1 };
      ^^^
help: change the value or the annotation so their types match; convert numbers explicitly with `value as <type>`

Extração de dados ​

DataOnly<T> ​

Remove todos os campos com tipo função, mantém apenas propriedades de dados puros. Ideal para payloads de API.

AssinaturaDataOnly<T> = { [K in keyof T as T[K] extends Function ? never : K]: T[K] }
tyrus
interface UserService {
    id: i32;
    name: string;
    save: () => boolean;
    notify: (string) => void;
}

type UserData = DataOnly<UserService>;
const data: UserData = { id: 1, name: "Ada" };

error

tyrus
interface ApiPayload {
    id: i32;
    name: string;
    validate: () => boolean;
}

type Data = DataOnly<ApiPayload>;
const bad: Data = { id: 1, name: "Ada", validate: () => true }; 
text
error[E2353]: object literal specifies unknown property `validate`
at /src/main.tyr:8:41
const bad: Data = { id: 1, name: "Ada", validate: () => true };
                                        ^^^^^^^^

Manipulação de união ​

Exclude<T, U> ​

Remove membros de U de T, mantém tudo em T que não está em U.

AssinaturaExclude<T, U> = T extends U ? never : T
tyrus
type T = Exclude<"a" | "b" | "c", "a">;
const v: T = "b";

error

tyrus
type T = Exclude<"a" | "b" | "c", "a">;
const v: T = "a"; 
text
error[E0308]: type mismatch for `v`: expected `"b" | "c"`, found `string`
at /src/main.tyr:2:7
const v: T = "a";
      ^
help: change the value or the annotation so their types match; convert numbers explicitly with `value as <type>`

Extract<T, U> ​

Mantém apenas membros de T que também pertencem a U, calcula a interseção.

AssinaturaExtract<T, U> = T extends U ? T : never
tyrus
type T = Extract<"a" | "b" | "c", "a" | "b">;
const v: T = "a";

error

tyrus
type T = Extract<"a" | "b" | "c", "a" | "b">;
const v: T = "c"; 
text
error[E0308]: type mismatch for `v`: expected `"a" | "b"`, found `string`
at /src/main.tyr:2:7
const v: T = "c";
      ^
help: change the value or the annotation so their types match; convert numbers explicitly with `value as <type>`

Tipos condicionais ​

Tipos condicionais escolhem entre dois tipos em tempo de compilação. A restrição extends seleciona o ramo, e infer extrai um tipo de dentro da estrutura correspondente.

T extends U ? X : Y ​

Um tipo condicional resolve para X quando T satisfaz a restrição U, e para Y caso contrário.

AssinaturaT extends U ? Then : Else
tyrus
type IsString<T> = T extends string ? boolean : i32;
type FromString = IsString<string>;
const flag: FromString = true;

error

tyrus
type IsString<T> = T extends string ? boolean : i32;
type FromNumber = IsString<i32>;
const count: FromNumber = "zero"; 
text
error[E0308]: type mismatch for `count`: expected `i32`, found `string`
at /src/main.tyr:3:7
const count: FromNumber = "zero";
      ^^^^^
help: change the value or the annotation so their types match; convert numbers explicitly with `value as <type>`

infer R ​

Vincula uma variável de tipo dentro da restrição de um condicional, quando a restrição se mantém, o tipo inferido vira o ramo verdadeiro.

AssinaturaT extends (arg: i32) => infer R ? R : never
tyrus
type Fn = (i32) => string;
type Return<T> = T extends (arg: i32) => infer R ? R : never;
type Result = Return<Fn>;
const value: Result = "hello";

error

tyrus
type Fn = (i32) => string;
type Return<T> = T extends (arg: i32) => infer R ? R : never;
type Result = Return<Fn>;
const n: i32 = 42;
const value: Result = n; 
text
error[E0308]: type mismatch for `value`: expected `string`, found `i32`
at /src/main.tyr:5:7
const value: Result = n;
      ^^^^^
help: change the value or the annotation so their types match; convert numbers explicitly with `value as <type>`

Union Types ​

tyrus
type Shape =
    | { kind: "circle"; radius: f64 }
    | { kind: "square"; size: f64 }
    | { kind: "rect"; width: f64; height: f64 };

const printShape = (shape: Shape): void => {
    if (shape.kind === "circle") {
        print(shape.radius); // radius value
    } else if (shape.kind === "square") {
        print(shape.size); // size value
    } else {
        print(shape.width); // width value
        print(shape.height); // height value
    }
};

Tagged unions fazem narrowing por checagens de discriminante literal. O compilador rastreia branches positivos e negativos para que cada branch exponha os campos disponíveis no conjunto de variantes narrow.

Unions também funcionam com enums para payloads de eventos tipados:

tyrus
enum EventKind {
    Click,
    KeyPress,
    Submit,
}

type Event =
    | { kind: EventKind.Click; x: i32; y: i32 }
    | { kind: EventKind.KeyPress; key: string }
    | { kind: EventKind.Submit; formId: string };

const handleEvent = (event: Event): void => {
    match (event) {
        ({ kind: EventKind.Click, x, y }) => {
            print(`Click at (${x}, ${y})`); // "Click at (10, 20)"
        }
        ({ kind: EventKind.KeyPress, key }) => {
            print(`Key: ${key}`); // "Key: enter"
        }
        ({ kind: EventKind.Submit, formId }) => {
            print(`Submit: ${formId}`); // "Submit: login"
        }
    }
};

Enums algébricos ​

Enums algébricos modelam um conjunto fechado de variantes, onde cada variante pode não ter payload, ter campos posicionais ou campos nomeados. Um match sobre um enum algébrico deve ser exaustivo salvo se incluir _; padrões de tupla e struct vinculam diretamente o payload selecionado.

tyrus
enum Command {
    Quit,
    Move(i32, i32),
    ChangeColor { r: u8, g: u8, b: u8 },
}

const main = (): void => {
    const describe = (command: Command): i32 => {
        match (command) {
            Command.Quit => { return 0; }
            Command.Move(x, y) => { return x + y; }
            Command.ChangeColor { r, g, b } => { return (r + g + b) as i32; }
        }
    };

    const result = describe(Command.ChangeColor({ r: 10u8, g: 20u8, b: 30u8 }));

    print(result); // 60
};