Objetos e Interfaces
Tyrus usa sintaxis concisa para objetos, y interfaces nombradas y aliases de objeto hacen lowering a 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 impide reasignar el campo. Los campos opcionales se leen como T? y deben tratarse con narrowing o ??. Los literales de objeto se comprueban para campos ausentes, extra y con tipo incorrecto. Object spread crea updates inmutables con el mismo layout de interface del objeto fuente. Cuando el valor de un campo es una variable local con el mismo nombre, escribe el nombre una sola vez, { active } es azúcar sintáctico para { active: active }, y se combina libremente con campos explícitos key: value y con un spread update.
Métodos automáticos de datos
Cada interface de datos nombrada recibe métodos automáticos de datos sin anotaciones ni declaraciones. Los primeros cuatro son llamadas de instancia ordinarias y fromJson es una llamada estática en el nombre concreto de la interface. Una interface de comportamiento puede definir un método de instancia con el mismo nombre y tiene precedencia sobre el método automático.
copy()
Crea una copia estructural independiente.
copy() no es solo para objetos: existe en todo valor que posee un buffer, es decir, todo tipo que no es Copy. Eso cubre string, arrays, tuplas y los opcionales, results y uniones construidos a partir de ellos. En un escalar Copy como i32 el método no existe, porque let a = b ya duplica y un método sugeriría que ocurre otra cosa.
El resultado es un valor corriente de su propio tipo. Una decoración pertenece al campo del que se leyó el valor, no al valor, así que nada de la declaración de origen acompaña a la copia.
Leer un campo en un binding del mismo tipo lo mueve: const items = order.items; entrega el campo a items, order sigue siendo utilizable por sus otros campos, y leer order.items u order entero después se rechaza (E0382) hasta que el campo se asigna de nuevo. Donde el movimiento no puede ocurrir, el compilador sugiere copy(): cuando los campos del dueño tienen validators, cuyas reglas describen el valor entero, cuando el campo se alcanza a través de una referencia, o cuando el binding se declara con un tipo distinto del campo, como un string leído de un string? estrechado (E3081). order.items.copy() dice lo que hace y mantiene el coste visible, cosa que una copia insertada en silencio no haría.
interface User { name: string; }
const user: User = { name: "Ada" };
const copied: User = user.copy();
print(copied); // { name: "Ada" }equals(other: Type)
Compara campos elegibles estructuralmente, incluidos los campos opcionales ausentes y presentes. Los arrays no son elegibles porque su igualdad es por dirección. El argumento debe tener la misma interface nominal.
interface User { name: string; }
const first: User = { name: "Ada" };
const second: User = { name: "Ada" };
const same: boolean = first.equals(second); // trueUna interface con campos coincidentes todavía no puede pasarse a equals() cuando tiene otro nombre:
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()
Produce una representación legible en el orden declarado de los campos, entrecomilla y escapa strings, muestra campos opcionales ausentes como None y renderiza valores anidados 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 con un espacio después de cada dos puntos. Pasa { pretty: true } para JSON de varias líneas con sangría de cuatro espacios. Las claves salen en orden alfabético, no en el orden de declaración, para que el mismo dato produzca siempre el mismo texto: añadir un campo después no mueve los que ya estaban. Un decimal se escribe en notación común, el mismo texto con el que se imprime: 12.50d sale como 12.5, con todos los dígitos preservados y sin redondeo.
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
]
}
*/Un campo que lleva una unión discriminada se escribe como el objeto que su variante viva ya es: no hay envoltorio, y el campo discriminante es lo que le dice al lector qué variante recibió. fromJson la lee de vuelta del mismo modo, eligiendo la variante por su discriminante; un discriminante que no nombra ninguna variante declarada se rechaza con ERR_JSON_UNKNOWN_VARIANT en lugar de adivinarse, que es justamente para lo que se escribe.
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 sintaxis, campos, tipos y rangos numéricos, y devuelve JsonError con code estable, message legible y path de campo en lugar de lanzar.
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);
}
}Usa onfail para imprimir un JsonError y terminar la función void actual cuando falle la decodificación:
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 comportamiento con at
Las interfaces de comportamiento adjuntan métodos ejecutables a uno o más tipos receptores mediante at. El receptor es el primer parámetro explícito, así que el método sigue siendo ordinario y la llamada usa la sintaxis value.method(). Cuando se omite su anotación para múltiples objetivos, el compilador especializa y comprueba la implementación por separado para cada objetivo. Una interface de comportamiento contiene métodos o shorthand bindings, no campos de datos.
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(); // trueLos shorthand bindings nombran funciones declaradas en el mismo módulo o importadas desde otro módulo. Sus firmas se comprueban cuando se declara el comportamiento, y la firma importada se conserva entre módulos para la comprobación de tipos y la generación de código nativo. Las interfaces de comportamiento también pueden usar extend para heredar métodos de otras interfaces de comportamiento.
El receptor de at puede ser una interface nombrada o un tipo primitivo. La misma sintaxis de llamada por miembro funciona para valores numéricos, strings, booleanos y chars.
Acceso a propiedad por nombre
Un campo se lee y se escribe con la forma de punto y con un literal de cadena entre corchetes, los dos son el mismo acceso: la clave está escrita en el código, así que nombra un campo que el compilador conoce, y ambos compilan al mismo offset fijo.
interface Person {
name: string;
age: i32;
}
let person: Person = { name: "Ada", age: 36 };
print(person.name);
print(person["name"]);
person["age"] = 42;Solo un literal califica. person[clave], con clave siendo una variable, es error de compilación (E0608): una interfaz tiene un conjunto fijo de campos y ninguna búsqueda en tiempo de ejecución a la que recurrir. Un literal que no nombra ningún campo es E0609, reportado con el nombre. Para claves decididas en tiempo de ejecución, usa Record<string, T>, que es un hash map de verdad, lookup["a"] allí es una búsqueda que puede fallar, así que devuelve T?.
Asignación de campo
Un campo puede asignarse en el lugar con object.field = value, incluidas las formas compuestas como +=, a través de receptores anidados y en elementos indexados.
interface Point {
x: i64;
y: i64;
}
let point: Point = { x: 1, y: 2 };
point.x = 10;
point.y += 5;La asignación en el lugar exige un binding mutable: un binding const es profundamente inmutable, y un campo readonly o un valor de un tipo readonly rechaza la escritura. La asignación en el lugar hoy funciona para campos de número, booleano y char; para cambiar un campo string, un array o un objeto anidado, construye un nuevo valor con object spread.
Herencia de Interface
Una interface puede extend una o más interfaces para heredar sus campos. La interface hija exige todos los campos heredados más los propios, así que un valor del tipo hijo debe proporcionarlos todos. La herencia solo hace merge de campos, no hace que la hija sea asignable a la padre (ver el layout nominal abajo).
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 };Intersección de Tipos
Un alias type combina tipos de objeto con &. El alias exige todos los campos de todos los operandos, exactamente como lo hace la herencia, y cada operando es una interface nombrada o un objeto escrito inline. El & es la forma del alias de lo que extend hace en una interface: interface hereda con extend, type combina con &.
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]" };Cuando dos operandos declaran el mismo campo con tipos distintos, el alias se rechaza donde está escrito (E3214) en lugar de producir un campo que ningún valor puede satisfacer.
error
interface Metric {
value: i32;
}
interface Label {
value: string;
}
type Mixed = Metric & Label; El & pertenece a un alias type y a ningún otro lugar. No se acepta en una anotación de tipo (E3215): nombra la intersección primero y después usa el nombre.
error
interface Age {
age: u32;
}
interface Contact {
email: string;
}
function greet(person: Age & Contact): void {
print(person.email);
}Todo operando debe ser un tipo de objeto. Un operando que sea un primitivo, un array, una unión o una función se rechaza con E3213, y un alias que se refiere a sí mismo por la cadena se rechaza con E3216. Mezclar & y | en el mismo alias se rechaza con E3217, un diagnóstico propio porque el motivo es la precedencia: el | liga más fuerte, así que type A = B & C | D; se leería como B & (C | D). Los paréntesis por sí solos no ayudan, ya que una unión nunca es un operando válido. Nombra la intersección y usa ese nombre en la unión: type BC = B & C; y después type A = BC | D;.
Layout Nativo Nominal
En tyrus no trata toda forma de objeto compatible como intercambiable. Las interfaces son tipos producto nativos nombrados, así que pasar un CompleteUser donde se espera SummaryUser exige un objeto de conversión 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 varias formas en una misma colección, usa una tagged union con un campo discriminante literal y match en lugar de una interface base compartida, conserva los campos de cada variante y mantiene la exhaustividad:
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 },
];Orden de Almacenamiento de los Campos
Los campos se almacenan en el orden que desperdicia menos espacio, que no siempre es el orden en que fueron escritos: un campo ancho se coloca delante de uno estrecho para que el hueco que el estrecho dejaría antes de él desaparezca. La interface de abajo ocupa 40 bytes escrita así y 24 bytes almacenada, y guardar un millón de ellas es la diferencia entre 40 MB y 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 cambia en el uso de la interface: los campos se leen, escriben, esparcen y desestructuran por nombre, un literal de objeto sigue evaluando sus campos en el orden en que los lista, e imprimir un valor sigue mostrando los campos en el orden en que la interface los declara. El orden es una decisión de almacenamiento y nunca es observable desde el programa.
Type Aliases
type Point = {
x: i32;
y: i32;
};Para formas de objeto, type e interface son equivalentes en layout nativo. Un alias type también puede nombrar unions, tuplas, tipos de función y utility types.
Utilidades de Tipo
| Categoría | Utilities |
|---|---|
| Transformación de objeto | Partial<T>, Optional<T, K>, Required<T>, Readonly<T>, DeepPartial<T> |
| Selección de claves | Pick<T, K>, Omit<T, K> |
| Selección por tipo | PickByType<T, Type>, OmitByType<T, Type> |
| Renombrado de claves | CamelCaseKeys<T>, SnakeCaseKeys<T> |
| Control de campos | Require<T, K>, AtLeastOne<T, K> |
| Extracción de datos | DataOnly<T> |
| Mapeo clave/valor | keyof, Record<K, T> |
| Tipos de función | ReturnType<T>, Parameters<T> |
| Manipulación de uniones | Exclude<T, U>, Extract<T, U> |
| Tipos condicionales | T extends U ? X : Y, infer R |
Transformación de objeto
Partial<T>
Vuelve todo campo opcional, quien llama puede proporcionar cualquier 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>
Mantiene todos los campos y vuelve opcionales solo las claves seleccionadas. La forma existente de un argumento, Optional<T>, sigue siendo la sintaxis 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>
Vuelve todo campo opcional en obligatorio, todos los campos deben ser proporcionados.
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>
Impide la reasignación de campos, el objeto entero se vuelve profundamente inmutable. Es uno de los seis lugares donde aparece la palabra clave; la página Readonly los cubre todos.
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>
Vuelve todo campo opcional recursivamente, hasta 5 niveles de profundidad. Ideal para payloads de actualización 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>`Selección de claves
Pick<T, K>
Selecciona un subconjunto de campos por clave, el resultado solo tiene las claves 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>
Elimina un subconjunto de campos por clave, el resultado tiene todo excepto las claves 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 neededProyecciones de valor
value.pick(keys) y value.omit(keys) crean un objeto nuevo con los campos seleccionados o restantes. Las claves deben conocerse durante la compilación, en un array literal o en una variable con tipo finito de claves literales. El receptor no se muta, el orden de los campos sigue el tipo de origen y no hay búsqueda de claves en 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);Selección por tipo
PickByType<T, Type>
Selecciona campos por su tipo de valor, mantiene solo los campos cuyo 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>
Elimina campos por su tipo de valor, excluye todos los campos cuyo 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" };
^^^^Mapeo clave/valor
keyof
Extrae las claves de un tipo como una unión 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> es un tipo de utilidad integrado, como Pick<T, K> y Omit<T, K>. El compilador lo resuelve y no crea una clase Record en runtime. Cuando K es una unión finita de claves string literales, Tyrus produce un tipo objeto con un campo obligatorio por clave. Cuando K es abierto, como string, Tyrus lo resuelve como Map<K, T>, adecuado para claves dinámicas.
Record<K extends string, T> = campos obligatorios de objeto para K literal finito; Map<K, T> para K abiertotype 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");Renombrado de claves
CamelCaseKeys<T>
Transforma todos los nombres de campo de snake_case a camelCase. Esencial para integraciones con 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 los nombres de campo de camelCase a snake_case. Útil para payloads de APIs legadas y bases de datos.
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 función
ReturnType<T>
Infiera el tipo de retorno de un tipo función, extrae lo que la función produce.
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>
Infiera los tipos de los parámetros de un tipo función como tupla, extrae lo que la función 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;
^Control de campos
Require<T, K>
Vuelve campos específicos obligatorios. Es un noop si el campo ya es obligatorio.
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>
Vuelve todos los campos especificados opcionales pero requiere que al menos uno de ellos esté presente. Cada clave de K debe ser una propiedad 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>`Extracción de datos
DataOnly<T>
Elimina todos los campos con tipo función, mantiene solo propiedades de datos 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 };
^^^^^^^^Manipulación de uniones
Exclude<T, U>
Elimina miembros de U de T, mantiene todo en T que no está en 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>
Conserva solo miembros de T que también pertenecen a U, calcula la intersección.
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 condicionales
Los tipos condicionales eligen entre dos tipos en tiempo de compilación. La restricción extends selecciona la rama, y infer extrae un tipo de dentro de la estructura coincidente.
T extends U ? X : Y
Un tipo condicional se resuelve a X cuando T satisface la restricción U, y a Y en caso contrario.
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 una variable de tipo dentro de la restricción de un condicional, cuando la restricción se cumple, el tipo inferido se convierte en la rama verdadera.
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 hacen narrowing mediante comprobaciones de discriminante literal. El compilador rastrea branches positivos y negativos para que cada branch exponga los campos disponibles del conjunto de variantes narrowed.
Las unions también funcionan con 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 algebraicos
Los enums algebraicos modelan un conjunto cerrado de variantes, donde cada variante puede no tener payload, tener campos posicionales o campos con nombre. Un match sobre un enum algebraico debe ser exhaustivo salvo que incluya _; los patrones de tupla y struct vinculan directamente el payload seleccionado.
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
};