Skip to content

Objetos e Interfaces ​

Tyrus usa sintaxis concisa para objetos, y interfaces nombradas y aliases de objeto hacen lowering a 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 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.

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

tyrus
interface User { name: string; }

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

Una interface con campos coincidentes todavía no puede pasarse a equals() cuando tiene otro nombre:

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() ​

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.

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

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
    ]
}
*/

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.

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 sintaxis, campos, tipos y rangos numéricos, y devuelve JsonError con code estable, message legible y path de campo en lugar de lanzar.

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);
    }
}

Usa onfail para imprimir un JsonError y terminar la función void actual cuando falle la decodificación:

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

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

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

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

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

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 };

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

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]" };

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

tyrus
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

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

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

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 },
];

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.

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

tyrus
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íaUtilities
Transformación de objetoPartial<T>, Optional<T, K>, Required<T>, Readonly<T>, DeepPartial<T>
Selección de clavesPick<T, K>, Omit<T, K>
Selección por tipoPickByType<T, Type>, OmitByType<T, Type>
Renombrado de clavesCamelCaseKeys<T>, SnakeCaseKeys<T>
Control de camposRequire<T, K>, AtLeastOne<T, K>
Extracción de datosDataOnly<T>
Mapeo clave/valorkeyof, Record<K, T>
Tipos de funciónReturnType<T>, Parameters<T>
Manipulación de unionesExclude<T, U>, Extract<T, U>
Tipos condicionalesT extends U ? X : Y, infer R

Transformación de objeto ​

Partial<T> ​

Vuelve todo campo opcional, quien llama puede proporcionar cualquier subconjunto.

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

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

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

Vuelve todo campo opcional en obligatorio, todos los campos deben ser proporcionados.

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

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.

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

Vuelve todo campo opcional recursivamente, hasta 5 niveles de profundidad. Ideal para payloads de actualización parcial (PATCH).

FirmaDeepPartial<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>`

Selección de claves ​

Pick<T, K> ​

Selecciona un subconjunto de campos por clave, el resultado solo tiene las claves listadas.

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

Elimina un subconjunto de campos por clave, el resultado tiene todo excepto las claves listadas.

FirmaOmit<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

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

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);

Selección por tipo ​

PickByType<T, Type> ​

Selecciona campos por su tipo de valor, mantiene solo los campos cuyo tipo corresponde a Type.

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

Elimina campos por su tipo de valor, excluye todos los campos cuyo tipo corresponde a Type.

FirmaOmitByType<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" };
                        ^^^^

Mapeo clave/valor ​

keyof ​

Extrae las claves de un tipo como una unión literal de string.

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

FirmaRecord<K extends string, T> = campos obligatorios de objeto para K literal finito; Map<K, T> para K abierto
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");

Renombrado de claves ​

CamelCaseKeys<T> ​

Transforma todos los nombres de campo de snake_case a camelCase. Esencial para integraciones con APIs externas.

FirmaCamelCaseKeys<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 los nombres de campo de camelCase a snake_case. Útil para payloads de APIs legadas y bases de datos.

FirmaSnakeCaseKeys<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 función ​

ReturnType<T> ​

Infiera el tipo de retorno de un tipo función, extrae lo que la función produce.

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

Infiera los tipos de los parámetros de un tipo función como tupla, extrae lo que la función espera.

FirmaParameters<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;
^

Control de campos ​

Require<T, K> ​

Vuelve campos específicos obligatorios. Es un noop si el campo ya es obligatorio.

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

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.

FirmaAtLeastOne<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>`

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.

FirmaDataOnly<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 };
                                        ^^^^^^^^

Manipulación de uniones ​

Exclude<T, U> ​

Elimina miembros de U de T, mantiene todo en T que no está en U.

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

Conserva solo miembros de T que también pertenecen a U, calcula la intersección.

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

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

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

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

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
};