Tipos
Tyrus usa anotaciones de tipo y semántica nativa aplicada por el compilador. Los valores normalmente pueden inferirse desde los inicializadores, pero las anotaciones explícitas son recomendables en fronteras de API y cuando el ancho numérico importa.
La inferencia es local y predecible
const answer = 42; se infiere desde el literal. Usa const answer: i64 = 42; cuando el ancho forma parte del contrato.
Un literal de objeto nombra su interfaz
Las interfaces son nominales, así que un literal declara la interfaz que construye en vez de que se adivine por su forma: const user: User = { id: 1 };. Un literal de objeto sin anotación es un error, y el help: nombra cada interfaz con forma compatible, ofrecida en el editor como Quick Fix. Adivinar por la forma haría que el significado de un archivo dependiera de todas las interfaces del programa.
Tipos primitivos
| Tipo | Úsalo para | Ejemplo |
|---|---|---|
boolean | Valores de verdad y condiciones de branch. | const enabled: boolean = true; |
i8 | Bytes y valores con signo pequeños, de un byte de ancho. | const delta: i8 = -8; |
i16 | Valores con signo pequeños, de dos bytes de ancho. | const offset: i16 = -1024; |
i32 | Entero con signo default para contadores, IDs y la mayoría de la aritmética. | const count: i32 = 42; |
i64 | Enteros con signo grandes, timestamps e identificadores persistidos. | const micros: i64 = 1720000000000; |
i128 | Cálculos enteros con signo muy grandes. | const ledger: i128 = 9000000000000000000; |
isize | Índices con signo pointer-sized y valores de tamaño nativo. | const offset: isize = -1; |
u8 | Bytes, códigos de protocolo y canales de color. | const red: u8 = 255; |
u16 | Puertos, code points y campos de protocolo de dos bytes. | const port: u16 = 8080; |
u32 | Contadores y tamaños unsigned que caben en 32 bits. | const size: u32 = 4096; |
u64 | Contadores e identificadores unsigned grandes. | const sequence: u64 = 10000000000; |
u128 | Cálculos enteros unsigned muy grandes. | const mask: u128 = 340282366920938463463374607431768211455; |
usize | Índices, longitudes y capacidades unsigned pointer-sized. | const length: usize = names.length; |
f32 | Valores de punto flotante compactos cuando el tradeoff de precisión es aceptable. | const ratio: f32 = 0.75; |
f64 | Cálculos de punto flotante default. | const total: f64 = 19.99; |
f128 | Cálculos de punto flotante extendidos y constantes nativas min/max. | const largest: f128 = f128.MAX; |
decimal | Aritmética exacta de base diez con 34 dígitos significativos. | const total: decimal = 0.1d + 0.2d; |
char | Un único carácter Unicode, para recorrer texto carácter a carácter. | const letter: char = 'A'; |
string | Texto UTF-8 con ownership. | const label: string = "tyrus"; |
void | Funciones que no devuelven valor. | function log(): void { print("ok"); } |
unknown | Valores que necesitan narrowing antes del uso. | const payload: unknown = readInput(); |
never | Caminos de código que no retornan normalmente. | function fail(message: string): never { throw message; } |
Tipos numéricos
Usa enteros con signo (i*) cuando los valores pueden ser negativos. Usa enteros unsigned (u*) para bytes, tamaños, campos de protocolo y valores que nunca pueden ser negativos. Usa f32/f64 para valores fraccionarios, no para dinero ni contadores exactos.
const inferredInteger = 42;
const inferredFloat = 3.14;
const explicitId: i64 = 42;
const byte: u8 = 255;
const price: f64 = 19.99;Métodos algebraicos de punto flotante
f32 y f64 proporcionan algebraicAdd, algebraicSub, algebraicMul, algebraicDiv y algebraicRem. Corresponden respectivamente a suma, resta, multiplicación, división y resto, y permiten explícitamente que el compilador reasocie el cálculo de punto flotante seleccionado para optimización. Los resultados pueden variar entre builds y targets, incluso para NaN, infinito y cero con signo. Los operadores aritméticos normales permanecen estrictos.
const left: f64 = 6.0;
const right: f64 = 4.0;
const x: f32 = 3.0;
const y: f32 = 4.0;
const sum: f64 = left.algebraicAdd(right);
const difference: f64 = left.algebraicSub(right);
const product: f32 = x.algebraicMul(y);
const quotient: f64 = left.algebraicDiv(right);
const remainder: f64 = left.algebraicRem(right);
print(sum); // 10.0
print(difference); // 2.0
print(product); // 12.0
print(quotient); // 1.5
print(remainder); // 2.0Valores especiales de punto flotante
Infinity y NaN son literales reservados de punto flotante disponibles sin importación. -Infinity es el - unario aplicado a Infinity. Se infieren como f64 y pueden recibir contexto como f32, f64 o f128. La aritmética de punto flotante sigue IEEE 754, incluso para resultados no finitos; la división entera por cero sigue siendo un error de runtime.
const positive: f64 = Infinity;
const negative: f32 = -Infinity;
const invalid: f128 = NaN;
print(isNaN(invalid)); // true
print(NaN === NaN); // false
print(NaN !== NaN); // trueisNaN(value) acepta un valor de punto flotante y devuelve boolean. La igualdad no identifica NaN: toda comparación de igualdad con él es falsa, mientras que toda comparación de desigualdad es verdadera.
El ancho numérico forma parte del tipo
Pasar un i64 donde se espera un i32 exige conversión explícita de narrowing. El compilador rechaza narrowing implícito porque puede perder datos.
error
function takesI32(value: i32): void {
print(value);
}
const large: i64 = 9000;
takesI32(large);
takesI32(large as i32);error
error[E0308]: type mismatch for `argument 1 of `takesI32``: expected `i32`, found `i64`
at /src/main.tyr:7:1
takesI32(large);
^^^^^^^^^^^^^^^
help: `i64` does not convert to `i32` on its own; write the conversion explicitly with `as i32`Constantes numéricas
Los tipos numéricos exponen constantes MIN y MAX mediante sintaxis de propiedad en el nombre del tipo.
const i8MIN = i8.MIN; // -128
const i8MAX = i8.MAX; // 127
const u8MIN = u8.MIN; // 0
const u8MAX = u8.MAX; // 255
const i16MIN = i16.MIN; // -32768
const i16MAX = i16.MAX; // 32767
const u16MIN = u16.MIN; // 0
const u16MAX = u16.MAX; // 65535
const i32MIN = i32.MIN; // -2147483648
const i32MAX = i32.MAX; // 2147483647
const u32MIN = u32.MIN; // 0
const u32MAX = u32.MAX; // 4294967295
const i64MIN = i64.MIN; // -9223372036854775808
const i64MAX = i64.MAX; // 9223372036854775807
const u64MIN = u64.MIN; // 0
const u64MAX = u64.MAX; // 18446744073709551615
const i128MIN = i128.MIN; // -170141183460469231731687303715884105728
const i128MAX = i128.MAX; // 170141183460469231731687303715884105727
const u128MIN = u128.MIN; // 0
const u128MAX = u128.MAX; // 340282366920938463463374607431768211455
const f32MIN = f32.MIN; // -340282346638528859811704183484516925440.0
const f32MAX = f32.MAX; // 340282346638528859811704183484516925440.0
const f64MIN = f64.MIN; // -1.797693134862315708145274237317e+308
const f64MAX = f64.MAX; // 1.797693134862315708145274237317e+308
const f128MIN = f128.MIN; // -1.189731495357231765085759326628007e+4932
const f128MAX = f128.MAX; // 1.189731495357231765085759326628007e+4932
const decimalMIN = decimal.MIN; // -9.999999999999999999999999999999999e+6144
const decimalMAX = decimal.MAX; // 9.999999999999999999999999999999999e+6144Sintaxis de literales numéricos
Tyrus admite literales enteros hexadecimales, binarios, octales y decimales, con guiones bajos opcionales como separadores visuales. Los prefijos y dígitos hexadecimales no distinguen entre mayúsculas y minúsculas. Los separadores de enteros decimales deben agrupar los dígitos en conjuntos de tres. Los literales enteros positivos por encima de i128.MAX requieren un contexto u128 explícito y no pueden superar u128.MAX; el límite negativo con signo es i128.MIN. La notación científica se admite en literales decimales de punto flotante, y las partes enteras grandes no se amplían implícitamente a f128.
// Hexadecimal: 0x or 0X prefix; hexadecimal digits may use A-F or a-f.
const hex: i32 = 0xFF; // 255
const hexLower: i32 = 0xff; // 255
const hex2: i32 = 0xABCD; // 43981
const hexSep: i32 = 0xFF_FF; // 65535
// Binary: 0b or 0B prefix.
const binary: i32 = 0b1010; // 10
const binary2: i32 = 0B1111; // 15
// Octal: 0o or 0O prefix.
const octal: i32 = 0o77; // 63
const octal2: i32 = 0O755; // 493
// Decimal integer separators group digits in sets of three.
const big: i32 = 1_000_000; // 1000000
// Invalid decimal separators: 1_000_, 10_00, 1_00_0_000.
// Positive integer literals above i128.MAX require an explicit u128 context and may not exceed u128.MAX.
// The signed negative boundary is -170_141_183_460_469_231_731_687_303_715_884_105_728.
// Scientific notation is supported for decimal floating-point literals.
const sci: f64 = 1.5e10; // 15000000000
const sci2: f64 = 2.5E-3; // 0.0025
const sci3: f64 = 1e5; // 100000
// Plain decimal float literals with very large integer parts are rejected instead of being widened to f128 implicitly.Análisis decimal
parseDecimal(text) analiza una cadena decimal completa de base diez y devuelve decimal?. Texto no válido, un sufijo d o D, valores fuera del rango decimal y separadores malformados producen ausencia en lugar de una aproximación de punto flotante binario. Los casts de entero a decimal son exactos; un cast de decimal a entero exige un valor integral y rango suficiente en el destino.
const parsed: decimal? = parseDecimal("19.3");
const amount: decimal = parsed ?? 0d;
const fromInteger: decimal = 12i32 as decimal;
const count: i32 = 12.0d as i32;MIN de entero unsigned siempre es cero. isize y usize tienen el ancho de un puntero en la máquina para la que se compila el programa, así que sus límites no los fija el lenguaje: no exponen MIN ni MAX, y conviene usar un tipo de ancho fijo cuando el límite en sí importa.
Un literal entero debe caber en su tipo
const byte: u8 = 300; es un error de compilación (E0706) anclado en el literal, nunca un valor que da la vuelta en silencio. El editor ofrece un quick fix que ensancha el tipo al más estrecho que sostiene el valor.
Los literales numéricos pueden llevar un sufijo explícito de tipo entero o de punto flotante. El sufijo fija el tipo del literal, participa en la inferencia y es distinto de una conversión explícita con as.
const byte = 10u8;
const count = 1000u64;
const ratio = 3.14f32;
const money = 32.99d;
const values = [0u64, 1u64, 2u64];
const converted: i32 = 10u8 as i32;Caracteres
Un char guarda exactamente un carácter Unicode y nunca se infiere: llega por anotación, y el valor se escribe como un literal de un carácter. Texto de cualquier otra longitud es string.
const letter: char = 'A';
const emoji: char = '😀';
const upper: char = letter.toUpperCase();
const isLetter: boolean = letter.isAlphabetic();
const code: u32 = letter as u32;
const back: char = code as char;
const maybe: char? = 55296 as char?;
const letters: char[] = "héllo".chars();Las comillas no tienen significado, lo que hace que un valor sea un char es la anotación, pero tyrus fmt escribe un char con comillas simples y un string con el estilo de comillas configurado, así que ambos se distinguen a simple vista.
"Un carácter Unicode" significa un único valor escalar Unicode, un único punto de código, no un grafema, que es lo que el lector percibe como un símbolo. Algunos emoji son un único valor escalar y caben en un char; muchos se escriben con varios puntos de código y deben ser string:
| Emoji | Puntos de código | Cantidad | char |
|---|---|---|---|
| 😀 | U+1F600 | 1 | ✅ |
| 🇧🇷 | dos indicadores regionales (U+1F1E7 U+1F1F7) | 2 | ❌ |
| ❤️ | corazón más selector de variación (U+2764 U+FE0F) | 2 | ❌ |
| 👍🏽 | pulgar más modificador de tono de piel | 2 | ❌ |
| 👨👩👧👦 | familia, una secuencia ZWJ | 7 | ❌ |
Así const emoji: char = '😀'; se acepta, mientras que un emoji compuesto como '🇧🇷' falla en tiempo de compilación, a char holds exactly one character, but 🇧🇷 has 2, y el diagnóstico apunta a string.
char ofrece toUpperCase, toLowerCase, isDigit, isAlphabetic, isAlphanumeric, isWhitespace y toString. Mayúsculas y clasificación siguen las reglas de Unicode, no las de ASCII, así que 'ç'.toUpperCase() es 'Ç'. Convertir un entero en char está comprobado: un valor que no es un carácter Unicode aborta, y as char? devuelve ausencia.
Valores unknown
unknown guarda un valor cuyo tipo solo se conoce en tiempo de ejecución. Acepta un string, un boolean, un char, cualquier tipo numérico o un decimal, incluida una union de ellos, y no se puede hacer nada con el valor hasta que una comprobación typeof demuestre lo que guarda. En la rama donde typeof value === "string" es verdadero, value es un string. La comparación puede escribirse en cualquier orden, y la rama else de typeof value !== "string" se estrecha de la misma forma.
const describe = (value: unknown): string => {
if (typeof value === "string") {
return `text with ${value.length} characters`;
}
if (typeof value === "i32") {
return `the integer after ${value + 1}`;
}
return typeof value;
};
const main = (): void => {
print(describe("Tyrus")); // text with 5 characters
print(describe(41)); // the integer after 42
print(describe(true)); // boolean
};Fuera de la rama comprobada el valor sigue siendo unknown. Una comprobación de "object" o "function", o la rama donde la comprobación falló, no demuestra ningún tipo único y mantiene el valor como unknown. Comparar typeof con un nombre que nunca produce, como "number" o "String", es un error de compilación (E0795) anclado en el literal, y el editor ofrece un quick fix cuando se pretende exactamente una categoría.
Los arrays, objetos, interfaces, opcionales y funciones no pueden guardarse en unknown (E0794). Dale al valor un tipo que lo describa.
error
const main = (): void => {
const scores: unknown = [90, 85];
print(scores);
};error[E0794]: cannot store a value of type `integer literal[]` in `unknown`
at /src/main.tyr:2:11
const scores: unknown = [90, 85];
^^^^^^
help: `unknown` holds only `string`, `boolean`, `char`, numeric and `decimal` values, and `integer literal[]` is none of them
help: give `scores` a type that describes the valueTipos opcionales
T? representa un valor que puede estar ausente. tyrus no tiene undefined ni valor null: la ausencia no es un valor, sino el estado de un T? que no tiene valor.
const name: string? = getName();
const label: string = name ?? "anonymous";
const retries: Optional<i32> = 3;
const remaining: i32 = retries ?? 0;Como la ausencia no es un valor, la produces de cuatro formas: omitir un campo o parámetro opcional, escribir un return; vacío en una función cuyo retorno es T?, declarar un binding opcional sin inicializador (let x: T?; empieza vacío) o llamar a un método nativo que no encuentra nada (array.find). No hay literal null para escribir.
const findAccount = (found: boolean): Account? => {
if (found) {
return { id: 1 };
}
return; // empty
};
let pending: i32?; // starts empty
const size: usize? = pending?.length;
print(size ?? 0); // 0Lee miembros de un valor opcional con ?.. El acceso hace short-circuit cuando el receiver está ausente, y su resultado sigue siendo opcional: name?.length es usize?, no usize.
const size: usize? = name?.length;
const shouted: string? = name?.toUpperCase();
print(size ?? 0); // 0Trata valores opcionales antes del uso
El unwrap forzado con value! es rechazado por el compilador (E0716) porque puede convertir ausencia en falla de runtime. Haz narrowing del valor con if (value) o proporciona un fallback con ??.
Los tipos opcionales componen con colecciones y retornos de función:
const findFirst = <T>(items: T[], predicate: (item: T) => boolean): T? => {
for (const item of items) {
if (predicate(item)) {
return item;
}
}
return;
};
const numbers: i32[] = [1, 2, 3, 4, 5];
const first: i32? = findFirst(numbers, n => n > 3);
print(first ?? -1); // 4
interface Company {
ceo?: User;
}
const company: Company = {};
const ceoName: string? = company.ceo?.name;
print(ceoName ?? "no CEO"); // no CEOValores Result
Result<T, E> representa un payload de éxito exactamente T o un payload de error exactamente E. Todo valor retornado por una función Result debe envolverse en Ok(value) o Err(value), por lo que la variante elegida es explícita incluso cuando T y E difieren. El postfix ? extrae el payload de éxito y retorna el error desde la función actual cuando es necesario.
function loadUser(): Result<User, string> {
return Ok(fetchUser());
}
function render(): Result<void, string> {
const user = loadUser()?;
print(user.name);
return Ok();
}
function validate(active: boolean): Result<string, boolean> {
if (active) {
return Ok("ready");
}
return Err(false);
}
function printValidation(result: Result<string, boolean>): void {
match (result) {
Ok(value) => print(value);
Err(error) => print(error);
}
}Los tipos de los payloads deben ser exactos, y los payloads opcionales como Result<User?, string> son rechazados. Result<void, E> retorna éxito con Ok(). Un retorno vacío se rechaza con un Quick Fix para usar Ok(); un return value; sin constructor se rechaza con un Quick Fix que envuelve el valor en el único constructor compatible, u ofrece ambos constructores cuando los dos tipos de payload coinciden. Un result se estrecha con patrones explícitos Ok(binding) y Err(binding) en match, y ambas variantes son obligatorias salvo que un brazo _ explícito cubra el caso restante. Ok() está disponible cuando el payload de éxito es void. El operador ? es la alternativa explícita cuando el error debe propagarse al llamador.
? es un operador posfijo, por lo que el valor que desenvuelve puede participar en cualquier expresión: load()? + 1, load()? === 40, o una rama de ternario como wanted ? load()? : 0. Comparte el token con el ternario, y los dos se distinguen por lo que sigue: un ? cuya expresión siguiente va seguida de : abre un ternario, así que flag ? -1 : 2 sigue siendo un ternario mientras load()? - 1 propaga.
const load = (ok: boolean): Result<i32, string> => {
if (ok) {
return Ok(40);
}
return Err("boom");
};
const next = (ok: boolean): Result<i32, string> => {
return Ok(load(ok)? + 1);
};
const pick = (ok: boolean, wanted: boolean): Result<i32, string> => {
return Ok(wanted ? load(ok)? : 0);
};
const main = (): void => {
const flag = true;
print(flag ? -1 : 2); // -1
match (next(true)) {
Ok(value) => { print(value); } // 41
Err(error) => { printError(error); }
}
match (pick(false, true)) {
Ok(value) => { print(value); }
Err(error) => { printError(error); } // boom
}
};En una función async, el await abarca su operando hasta el primer ?, así que await loadUser(id)? espera la promesa y luego propaga el Result: const user = await loadUser(id)?; o return Ok(await load()? + 1);. Los paréntesis mantienen su significado, así que await (load()?) aplica el ? a la propia promesa, lo que se rechaza con un help que apunta a await load()?. Un await también puede ser el sujeto de un match o de un if, o el argumento de una llamada, incluso dentro de un bucle.
interface User {
name: string;
}
const loadUser = async (id: i32): Promise<Result<User, string>> => {
if (id === 1) {
const user: User = { name: "Ada" };
return Ok(user);
}
return Err(`no user ${id}`);
};
const greeting = async (id: i32): Promise<Result<string, string>> => {
const user = await loadUser(id)?;
return Ok(`hello ${user.name}`);
};
const main = async (): Promise<void> => {
for (let id = 1; id <= 2; id += 1) {
match (await greeting(id)) {
Ok(text) => { print(text); } // hello Ada
Err(error) => { printError(error); } // no user 2
}
}
};Manejo de fallos en línea
onfail es una guarda terminal adjunta al inicializador de un const o let simple. Maneja Result<T, E>, una Promise<Result<T, E>> esperada, una llamada directa con un único efecto throws E declarado o un rechazo esperado. El nombre declarado es el error dentro del handler y el valor de éxito después de él. Un handler nunca continúa con un valor de reemplazo: sale con return, throw, continue o break, y llegar a su final sale por él, retornando de una función void, devolviendo Err(name) desde una función que retorna Result<U, E> con el mismo tipo de error o propagando la excepción permitida. En una función que retorna cualquier otro tipo, el handler debe salir explícitamente (E0277).
function render(): Result<void, string> {
const result = loadUser() onfail {
printError(result);
};
print(result.name);
return Ok();
}Sobre un Result esperado, el Err se separa después del await, así que la misma guarda maneja los fallos de los módulos nativos. El handler en sí se ejecuta sin suspender, y un await dentro de él se rechaza (E3002).
import { ArchiveError, ArchiveSummary, pack } from "tyrus:archive";
const main = async (): Promise<void> => {
const summary = await pack("./data", "./backup.zip") onfail {
printError(summary.code);
};
print(summary.entries);
};Usa try/catch para varias operaciones protegidas, recuperación con un valor de reemplazo o un bloque finally. Un finally externo todavía se ejecuta exactamente una vez cuando termina un handler de onfail.
Tipos de objeto
interface Account {
id: i64;
email: string;
displayName?: string;
}
const account: Account = {
id: 1,
email: "[email protected]",
};Los literales de objeto se comprueban estructuralmente contra declaraciones de interface. Los campos opcionales se acceden como valores opcionales.
Arrays y tuplas
const scores: i32[] = [10, 20, 30];
const point: [i32, i32] = [10, 20];
const pair: Tuple<string, i32> = ["one", 1];Array repeat: [value; count]
Create an array where every element is the same value. The count must be a positive constant integer expression from 1 through 65,536:
const zeros: i32[] = [0; 5]; // [0, 0, 0, 0, 0]
const flags: boolean[] = [false; 4]; // [false, false, false, false]
const xs: i32[] = [1 + 2; 3]; // [3, 3, 3]
const greetings: string[] = ["hi"; 4]; // ["hi", "hi", "hi", "hi"]
const matrix: i32[][] = [[0; 3]; 3]; // [[0, 0, 0], [0, 0, 0], [0, 0, 0]]Array.withCapacity: pre-allocated arrays
Create an empty array with pre-allocated buffer space to avoid repeated reallocations during push. The element type comes from the variable annotation:
let xs: i32[] = Array.withCapacity(100);
// xs.length == 0, xs.capacity == 100
xs.push(1);
// xs.length == 1, xs.capacity == 100 (no reallocation)Los arrays guardan un tipo de elemento repetido. Las tuplas guardan una forma fija con un tipo conocido por posición.
Usa [valor; tamaño] para crear un array donde todos los elementos son iguales al valor dado. El tamaño debe ser un entero constante conocido en tiempo de compilación. Se soportan tanto tipos Copy (enteros, booleanos) como tipos no-Copy (strings, arrays anidados); los elementos no-Copy se clonan profundamente para cada posición.
Usa Array.withCapacity(n) para crear un array vacío con búfer preasignado. El tipo del elemento se infiere de la anotación de la variable. Esto evita realocaciones repetidas cuando se sabe aproximadamente cuántos elementos se van a insertar.
Constructores de tipos genéricos
Usa paréntesis angulares para proporcionar argumentos de tipo a constructores de tipo con nombre. Array<T> equivale a T[], y Tuple<T, ...> equivale a [T, ...]; elige la forma que haga más fácil leer el tipo circundante.
| Forma | Argumentos | Significado |
|---|---|---|
Array<T> | uno | Una secuencia mutable o inmutable de T; equivale a T[]. |
Tuple<T, ...> | cero o más | Una secuencia de longitud fija con un tipo por posición; equivale a [T, ...]. |
Optional<T> | uno | Un valor que puede estar ausente; equivale a T?. |
Range<T> | uno | Un range numérico producido por a..b o a..=b. |
Set<T> | uno | Una colección de valores únicos de T. |
Map<K, V> | dos | Una colección con claves de K a V. |
Record<K, V> | dos | Un objeto con claves K y valores V; Record<string, V> es un map dinámico. |
Promise<T> | uno | El resultado de trabajo asíncrono que se resuelve como T. |
Las utilidades de tipo de objetos también son genéricas: Partial<T>, Required<T>, Readonly<T>, DeepPartial<T>, Pick<T, K>, Omit<T, K>, PickByType<T, Type>, OmitByType<T, Type>, CamelCaseKeys<T>, SnakeCaseKeys<T>, Require<T, K>, AtLeastOne<T, K>, DataOnly<T>, Exclude<T, U>, Extract<T, U>, ReturnType<T> y Parameters<T>. Consulta Colecciones, Objetos e interfaces y Async y Await para sus operaciones y restricciones.
Tipos de función
function double(value: i32): i32 {
return value * 2;
}
const predicate: (value: i32)
=> boolean = (value: i32): boolean
=> value > 10;Las firmas de función incluyen tipos de parámetros y retorno. El compilador usa esas firmas para comprobación de llamadas, completion, hover y signature help.
Los tipos de función componen con otros constructores de tipo:
type Callback = (result: string) => void;
type AsyncOp = (url: string) => Promise<string>;
type Predicate<T> = (value: T) => boolean;
const process = (items: i32[], predicate: Predicate<i32>): i32[] => {
return items.filter(predicate);
};
const isEven = (n: i32): boolean => n % 2 === 0;
const evens: i32[] = process([1, 2, 3, 4, 5, 6], isEven);Las funciones pueden almacenarse en arrays y maps, permitiendo registros de callbacks y sistemas de eventos:
type Handler = (message: string) => void;
const handlers: Record<string, Handler[]> = {};
const on = (event: string, handler: Handler): void => {
if (handlers[event] === undefined) {
handlers[event] = [];
}
handlers[event].push(handler);
};
on("error", (msg) => printError(msg));
on("error", (msg) => logToFile(msg));Los paréntesis agrupan un tipo, así que un array de tipo función puede escribirse en forma inline en vez de solo a través de un alias:
type Mapper = (n: i32) => i32;
const viaAlias: Mapper[] = [double, triple];
const inline: ((n: i32) => i32)[] = [double, triple];
const grouped: (i32)[] = [1, 2, 3];Lo que separa un grupo de una lista de parámetros es la flecha, y solo es legible después del paréntesis de cierre: (n: i32) => i32 es un tipo función, (i32)[] es un array de i32. Un grupo contiene un solo tipo, sin nombre y sin ...; cualquier otra cosa es lista de parámetros y sigue exigiendo la flecha.
Un tipo de función puede declarar lo que la función puede lanzar: (string) => i32 throws string. Una llamada a través de un valor de ese tipo tiene que capturar o propagar esos errores, como una llamada directa, y una función que lanza no puede usarse donde el tipo de función no los declara (E3298). Una función async informa sus errores como rechazo, así que encaja en un tipo de función sin throws.
const parseDigit = (text: string): i32 throws string => {
if (text === "") {
throw "empty input";
}
return 1;
};
const parseOrZero = (parse: (string) => i32 throws string, text: string): i32 => {
try {
return parse(text);
} catch (error: string) {
console.error(error);
return 0;
}
};
const main = (): void => {
console.log(parseOrZero(parseDigit, ""));
};