Objetos e Interfaces
Tyrus usa sintaxe concisa para objetos, e interfaces nomeadas e aliases de objeto fazem lowering para layouts de struct nativos.
Interfaces
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.
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.
interface User { name: string; }
const first: User = { name: "Ada" };
const second: User = { name: "Ada" };
const same: boolean = first.equals(second); // trueUma interface com campos correspondentes ainda não pode ser passada para equals() quando tiver outro nome:
error
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);
};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.
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.
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.
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.
interface JsonError { readonly code: string; readonly message: string; readonly path: string; }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
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.
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// 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"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(); // trueinterface 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(); // trueShorthand 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.
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.
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).
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 &.
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
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
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.
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:
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.
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
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
| Categoria | Utilities |
|---|---|
| Transformação de objeto | Partial<T>, Optional<T, K>, Required<T>, Readonly<T>, DeepPartial<T> |
| Seleção de chaves | Pick<T, K>, Omit<T, K> |
| Seleção por tipo | PickByType<T, Type>, OmitByType<T, Type> |
| Renomeação de chaves | CamelCaseKeys<T>, SnakeCaseKeys<T> |
| Controle de campos | Require<T, K>, AtLeastOne<T, K> |
| Extração de dados | DataOnly<T> |
| Mapeamento chave/valor | keyof, Record<K, T> |
| Tipos de função | ReturnType<T>, Parameters<T> |
| Manipulação de union | Exclude<T, U>, Extract<T, U> |
| Tipos condicionais | T extends U ? X : Y, infer R |
Transformação de objeto
Partial<T>
Torna todo campo opcional, quem chama pode fornecer qualquer subconjunto.
Partial<T> = { [K in keyof T]?: T[K] }interface Account {
id: i32;
email: string;
active: boolean;
}
type AccountPatch = Partial<Account>;
const patch: AccountPatch = { email: "[email protected]" };error
interface Account {
id: i32;
email: string;
active: boolean;
}
type AccountPatch = Partial<Account>;
const patch: AccountPatch = { email: 42 }; 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?.
Optional<T, K extends keyof T> = { [P in keyof T]: P extends K ? T[P]? : T[P] }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.
Required<T> = { [K in keyof T]-?: T[K] }interface Config {
host?: string;
port?: i32;
}
type StrictConfig = Required<Config>;
const cfg: StrictConfig = { host: "localhost", port: 8080 };error
interface Config {
host?: string;
port?: i32;
}
type StrictConfig = Required<Config>;
const cfg: StrictConfig = { host: "localhost" }; 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.
Readonly<T> = { readonly [K in keyof T]: Readonly<T[K]> }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
let config: Frozen = { endpoint: { port: 8080 }, name: "api" };
config.name = "web"; 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
let config: Frozen = { endpoint: { port: 8080 }, name: "api" };
config.endpoint.port = 9090; 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
interface Tagged {
tags: string[];
}
let tagged: Readonly<Tagged> = { tags: ["a"] };
tagged.tags.push("b"); 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).
DeepPartial<T> = { [K in keyof T]?: DeepPartial<T[K]> }interface Config {
db: {
host: string;
port: i32;
};
active: boolean;
}
type ConfigPatch = DeepPartial<Config>;
const patch: ConfigPatch = {
db: {
host: "localhost"
}
};error
interface Config {
db: {
host: string;
port: i32;
};
active: boolean;
}
type ConfigPatch = DeepPartial<Config>;
const bad: ConfigPatch = { db: { host: 42 } }; 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.
Pick<T, K extends keyof T> = { [P in K]: T[P] }interface User {
id: i32;
name: string;
email: string;
role: string;
}
type UserSummary = Pick<User, "id" | "name">;
const summary: UserSummary = { id: 1, name: "Ada" };error
interface User {
id: i32;
name: string;
email: string;
}
type Bad = Pick<User, "id" | "missing">; 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.
Omit<T, K extends keyof T> = { [P in Exclude<keyof T, K>]: T[P] }interface User {
id: i32;
name: string;
email: string;
}
type PublicUser = Omit<User, "email">;
const pub: PublicUser = { id: 1, name: "Ada" };interface User {
id: i32;
name: string;
email: string;
}
type PublicUser = Omit<User, "email">;
const email = pub.email; 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 neededProjeçõ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.
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.
PickByType<T, Type> = { [K in keyof T as T[K] extends Type ? K : never]: T[K] }interface User {
id: i32;
name: string;
email: string;
active: boolean;
}
type UserStrings = PickByType<User, string>;
const preview: UserStrings = { name: "Ada", email: "[email protected]" };error
interface User {
id: i32;
name: string;
email: string;
}
type UserId = PickByType<User, i32>;
const bad: UserId = { name: "Ada" }; 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.
OmitByType<T, Type> = { [K in keyof T as T[K] extends Type ? never : K]: T[K] }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
interface User {
id: i32;
name: string;
email: string;
}
type UserData = OmitByType<User, string>;
const bad: UserData = { name: "Ada" }; 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.
keyof T = string literal union of T's keysinterface Account {
id: i32;
email: string;
}
type Key = keyof Account;
const k: Key = "id";error
interface Account {
id: i32;
email: string;
}
type Key = keyof Account;
const k: Key = "missing"; 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.
Record<K extends string, T> = campos obrigatórios de objeto para K literal finito; Map<K, T> para K abertotype Roles = Record<"admin" | "user", boolean>;
const perms: Roles = { admin: true, user: false };error
type Roles = Record<"admin" | "user", boolean>;
const perms: Roles = { admin: true }; 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:
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.
CamelCaseKeys<T> = { [K in camelCase<keyof T>]: T[snake_case<K>] }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
interface Config {
db_host: string;
db_port: i32;
}
type Cfg = CamelCaseKeys<Config>;
const bad: Cfg = { db_host: "localhost", db_port: 5432 }; 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.
SnakeCaseKeys<T> = { [K in snake_case<keyof T>]: T[camelCase<K>] }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
interface ApiConfig {
dbHost: string;
dbPort: i32;
}
type Legacy = SnakeCaseKeys<ApiConfig>;
const bad: Legacy = { dbHost: "localhost", dbPort: 5432 }; 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.
ReturnType<T extends (...args: any) => any> = T's return typetype Fn = (i32) => string;
type Result = ReturnType<Fn>; // stringerror
type NotFn = i32;
type Bad = ReturnType<NotFn>; 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.
Parameters<T extends (...args: any) => any> = T's parameter tupletype Fn = (i32, string) => boolean;
type Params = Parameters<Fn>;error
type NotFn = i32;
type Bad = Parameters<NotFn>; 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.
Require<T, K extends keyof T> = T & { [P in K]-?: T[P] }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
interface User {
id: i32;
name: string;
email: string;
}
type Strict = Partial<User> & Require<User, "id">;
const bad: Strict = { name: "Ada" }; 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 literalAtLeastOne<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.
AtLeastOne<T, K extends keyof T> = { [P in keyof T]: P extends K ? T[P]? : T[P] }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
interface User {
id: i32;
name: string;
email: string;
}
type Lookup = AtLeastOne<User, "name" | "email">;
const bad: Lookup = { id: 1 }; 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.
DataOnly<T> = { [K in keyof T as T[K] extends Function ? never : K]: T[K] }interface UserService {
id: i32;
name: string;
save: () => boolean;
notify: (string) => void;
}
type UserData = DataOnly<UserService>;
const data: UserData = { id: 1, name: "Ada" };error
interface ApiPayload {
id: i32;
name: string;
validate: () => boolean;
}
type Data = DataOnly<ApiPayload>;
const bad: Data = { id: 1, name: "Ada", validate: () => true }; 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.
Exclude<T, U> = T extends U ? never : Ttype T = Exclude<"a" | "b" | "c", "a">;
const v: T = "b";error
type T = Exclude<"a" | "b" | "c", "a">;
const v: T = "a"; 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.
Extract<T, U> = T extends U ? T : nevertype T = Extract<"a" | "b" | "c", "a" | "b">;
const v: T = "a";error
type T = Extract<"a" | "b" | "c", "a" | "b">;
const v: T = "c"; 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.
T extends U ? Then : Elsetype IsString<T> = T extends string ? boolean : i32;
type FromString = IsString<string>;
const flag: FromString = true;error
type IsString<T> = T extends string ? boolean : i32;
type FromNumber = IsString<i32>;
const count: FromNumber = "zero"; 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.
T extends (arg: i32) => infer R ? R : nevertype Fn = (i32) => string;
type Return<T> = T extends (arg: i32) => infer R ? R : never;
type Result = Return<Fn>;
const value: Result = "hello";error
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; 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
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:
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.
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
};