Skip to content

Tipos ​

Tyrus usa anotações de tipo e semântica nativa aplicada pelo compilador. Valores geralmente podem ser inferidos a partir dos inicializadores, mas anotações explícitas são recomendadas em fronteiras de API e quando a largura numérica importa.

Inferência é local e previsível

const answer = 42; é inferido a partir do literal. Use const answer: i64 = 42; quando a largura faz parte do contrato.

Um literal de objeto nomeia sua interface

Interfaces são nominais, então um literal declara a interface que constrói em vez de ter uma adivinhada pela forma: const user: User = { id: 1 };. Um literal de objeto sem anotação é erro, e o help: nomeia toda interface de forma compatível, oferecida no editor como Quick Fix. Adivinhar pela forma faria o significado de um arquivo depender de todas as interfaces do programa.

Tipos primitivos ​

TipoUse paraExemplo
booleanValores de verdade e condições de branch.const enabled: boolean = true;
i8Bytes e valores assinados pequenos, com um byte de largura.const delta: i8 = -8;
i16Valores assinados pequenos, com dois bytes de largura.const offset: i16 = -1024;
i32Inteiro assinado default para contadores, IDs e a maioria da aritmética.const count: i32 = 42;
i64Inteiros assinados grandes, timestamps e identificadores persistidos.const micros: i64 = 1720000000000;
i128Cálculos inteiros assinados muito grandes.const ledger: i128 = 9000000000000000000;
isizeÍndices assinados pointer-sized e valores de tamanho nativo.const offset: isize = -1;
u8Bytes, códigos de protocolo e canais de cor.const red: u8 = 255;
u16Portas, code points e campos de protocolo de dois bytes.const port: u16 = 8080;
u32Contadores e tamanhos unsigned que cabem em 32 bits.const size: u32 = 4096;
u64Contadores e identificadores unsigned grandes.const sequence: u64 = 10000000000;
u128Cálculos inteiros unsigned muito grandes.const mask: u128 = 340282366920938463463374607431768211455;
usizeÍndices, comprimentos e capacidades unsigned pointer-sized.const length: usize = names.length;
f32Valores de ponto flutuante compactos quando a troca de precisão é aceitável.const ratio: f32 = 0.75;
f64Cálculos de ponto flutuante default.const total: f64 = 19.99;
f128Cálculos de ponto flutuante estendidos e constantes nativas min/max.const largest: f128 = f128.MAX;
decimalAritmética exata de base dez com 34 algarismos significativos.const total: decimal = 0.1d + 0.2d;
charUm único caractere Unicode, para percorrer texto caractere a caractere.const letter: char = 'A';
stringTexto UTF-8 com ownership.const label: string = "tyrus";
voidFunções que não retornam valor.function log(): void { print("ok"); }
unknownValores que precisam de narrowing antes do uso.const payload: unknown = readInput();
neverCaminhos de código que não retornam normalmente.function fail(message: string): never { throw message; }

Tipos numéricos ​

Use inteiros assinados (i*) quando valores podem ser negativos. Use inteiros unsigned (u*) para bytes, tamanhos, campos de protocolo e valores que nunca podem ser negativos. Use f32/f64 para valores fracionários, não para dinheiro ou contadores exatos.

tyrus
const inferredInteger = 42;
const inferredFloat = 3.14;
const explicitId: i64 = 42;
const byte: u8 = 255;
const price: f64 = 19.99;

Métodos algébricos de ponto flutuante ​

f32 e f64 fornecem algebraicAdd, algebraicSub, algebraicMul, algebraicDiv e algebraicRem. Eles correspondem, respectivamente, à adição, subtração, multiplicação, divisão e resto, permitindo explicitamente que o compilador reassocie o cálculo de ponto flutuante selecionado para otimização. Os resultados podem variar entre builds e targets, inclusive para NaN, infinito e zero com sinal. Os operadores aritméticos normais permanecem estritos.

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

Valores especiais de ponto flutuante ​

Infinity e NaN são literais reservados de ponto flutuante disponíveis sem importação. -Infinity é o - unário aplicado a Infinity. Eles inferem f64 e podem receber contexto como f32, f64 ou f128. A aritmética de ponto flutuante segue IEEE 754, inclusive para resultados não finitos; divisão inteira por zero continua sendo erro de runtime.

tyrus
const positive: f64 = Infinity;
const negative: f32 = -Infinity;
const invalid: f128 = NaN;

print(isNaN(invalid)); // true
print(NaN === NaN);    // false
print(NaN !== NaN);    // true

isNaN(value) aceita um valor de ponto flutuante e retorna boolean. Igualdade não identifica NaN: toda comparação de igualdade com ele é falsa, enquanto toda comparação de desigualdade é verdadeira.

Largura numérica faz parte do tipo

Passar um i64 onde um i32 é esperado exige conversão explícita de narrowing. O compilador rejeita narrowing implícito porque pode perder dados.

error

tyrus
function takesI32(value: i32): void {
    print(value);
}

const large: i64 = 9000;

takesI32(large); 
takesI32(large as i32);

error

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

Tipos numéricos expõem constantes MIN e MAX por sintaxe de propriedade no nome do tipo.

tyrus
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+6144

Sintaxe de literais numéricos ​

O Tyrus aceita literais inteiros hexadecimais, binários, octais e decimais, com underscores opcionais como separadores visuais. Prefixos e dígitos hexadecimais não diferenciam maiúsculas de minúsculas. Os separadores de inteiros decimais devem agrupar os dígitos em conjuntos de três. Literais inteiros positivos acima de i128.MAX exigem um contexto u128 explícito e não podem exceder u128.MAX; o limite negativo com sinal é i128.MIN. A notação científica é aceita em literais decimais de ponto flutuante, e partes inteiras grandes não são ampliadas implicitamente para f128.

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

Parsing decimal ​

parseDecimal(text) interpreta uma string decimal completa de base dez e retorna decimal?. Texto inválido, sufixo d ou D, valores fora da faixa decimal e separadores malformados produzem ausência em vez de uma aproximação de ponto flutuante binário. Casts de inteiro para decimal são exatos; um cast de decimal para inteiro exige valor integral e faixa suficiente no destino.

tyrus
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 inteiro unsigned é sempre zero. isize e usize têm a largura de um ponteiro na máquina para a qual o programa é compilado, então seus limites não são fixados pela linguagem: eles não expõem MIN nem MAX, e um tipo de largura fixa deve ser usado quando o limite emsi importa.

Um literal inteiro precisa caber no seu tipo

const byte: u8 = 300; é erro de compilação (E0706) ancorado no literal, nunca um valor que dá a volta silenciosamente. O editor oferece um quick fix que alarga o tipo para o menor que comporta o valor.

Literais numéricos podem carregar um sufixo explícito de tipo inteiro ou de ponto flutuante. O sufixo fixa o tipo do literal, participa da inferência e é diferente de uma conversão explícita com as.

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

Um char guarda exatamente um caractere Unicode e nunca é inferido: ele chega por anotação, e o valor é escrito como um literal de um caractere. Texto de qualquer outro tamanho é string.

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

As aspas não têm significado, quem faz o valor ser um char é a anotação, mas o tyrus fmt escreve um char com aspas simples e uma string com o estilo de aspas configurado, então os dois se distinguem à primeira vista.

"Um caractere Unicode" significa um único valor escalar Unicode, um único ponto de código, não um grafema, que é o que o leitor percebe como um símbolo. Alguns emoji são um único valor escalar e cabem em um char; muitos são escritos com vários pontos de código e precisam ser string:

EmojiPontos de códigoQuantidadechar
😀U+1F6001✅
🇧🇷dois indicadores regionais (U+1F1E7 U+1F1F7)2❌
❤️coração mais seletor de variação (U+2764 U+FE0F)2❌
👍🏽polegar mais modificador de tom de pele2❌
👨‍👩‍👧‍👦família, uma sequência ZWJ7❌

Assim const emoji: char = '😀'; é aceito, enquanto um emoji composto como '🇧🇷' falha em tempo de compilação, a char holds exactly one character, but 🇧🇷 has 2, e o diagnóstico aponta para string.

O char oferece toUpperCase, toLowerCase, isDigit, isAlphabetic, isAlphanumeric, isWhitespace e toString. Caixa e classificação seguem as regras do Unicode, não as do ASCII, então 'ç'.toUpperCase() é 'Ç'. Converter um inteiro em char é checado: um valor que não é um caractere Unicode aborta, e as char? devolve ausência.

Valores unknown ​

unknown guarda um valor cujo tipo só é conhecido em tempo de execução. Ele aceita uma string, um boolean, um char, qualquer tipo numérico ou um decimal, inclusive uma union deles, e nada pode ser feito com o valor até que uma verificação typeof comprove o que ele guarda. No ramo em que typeof value === "string" é verdadeiro, value é uma string. A comparação pode ser escrita em qualquer ordem, e o ramo else de typeof value !== "string" é estreitado da mesma forma.

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

Fora do ramo comprovado o valor continua unknown. Uma verificação de "object" ou "function", ou o ramo em que a verificação falhou, não comprova nenhum tipo único e mantém o valor como unknown. Comparar typeof com um nome que ele nunca produz, como "number" ou "String", é um erro de compilação (E0795) ancorado no literal, e o editor oferece um quick fix quando exatamente uma categoria é a pretendida.

Arrays, objetos, interfaces, opcionais e funções não podem ser guardados em unknown (E0794). Dê ao valor um tipo que o descreva.

error

tyrus
const main = (): void => {
    const scores: unknown = [90, 85]; 
    print(scores);
};
text
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 value

Tipos opcionais ​

T? representa um valor que pode estar ausente. tyrus não tem undefined nem valor null: ausência não é um valor, e sim o estado de um T? que não tem valor.

tyrus
const name: string? = getName();
const label: string = name ?? "anonymous";

const retries: Optional<i32> = 3;
const remaining: i32 = retries ?? 0;

Como ausência não é um valor, você a produz de quatro formas: omitir um campo ou parâmetro opcional, escrever um return; vazio numa função cujo retorno é T?, declarar um binding opcional sem inicializador (let x: T?; começa vazio) ou chamar um método nativo que não encontra nada (array.find). Não há literal null para escrever.

tyrus
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); // 0

Leia membros de um valor opcional com ?.. O acesso faz short-circuit quando o receiver está ausente, e o resultado continua opcional: name?.length é usize?, não usize.

tyrus
const size: usize? = name?.length;
const shouted: string? = name?.toUpperCase();

print(size ?? 0); // 0

Trate valores opcionais antes do uso

Unwrap forçado com value! é rejeitado pelo compilador (E0716) porque pode transformar ausência em falha de runtime. Faça narrowing do valor com if (value) ou forneça um fallback com ??.

Tipos opcionais se compõem com coleções e retornos de função:

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

Valores Result ​

Result<T, E> representa um payload de sucesso exatamente T ou um payload de erro exatamente E. Todo valor retornado por uma função Result precisa ser envolvido por Ok(value) ou Err(value), portanto a variante escolhida fica explícita mesmo quando T e E diferem. O postfix ? extrai o payload de sucesso e retorna o erro pela função atual quando necessário.

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

Os tipos dos payloads devem ser exatos, e payloads opcionais como Result<User?, string> são rejeitados. Result<void, E> retorna sucesso com Ok(). Um retorno vazio é rejeitado com Quick Fix para usar Ok(); um return value; sem construtor é rejeitado com Quick Fix que envolve o valor no único construtor compatível, ou oferece ambos os construtores quando os dois tipos de payload coincidem. Um result é estreitado com padrões explícitos Ok(binding) e Err(binding) no match, e ambas as variantes são exigidas salvo quando um braço _ explícito cobre o caso restante. Ok() está disponível quando o payload de sucesso é void. O operador ? é a alternativa explícita quando o erro deve ser propagado ao chamador.

? é um operador pós-fixo, então o valor que ele desembrulha pode participar de qualquer expressão: load()? + 1, load()? === 40, ou um ramo de ternário como wanted ? load()? : 0. Ele compartilha o token com o ternário, e os dois se distinguem pelo que vem depois: um ? cuja expressão seguinte é seguida de : abre um ternário, então flag ? -1 : 2 continua sendo ternário enquanto load()? - 1 propaga.

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

Numa função async, o await abrange o operando até o primeiro ?, então await loadUser(id)? espera a promise e depois propaga o Result: const user = await loadUser(id)?; ou return Ok(await load()? + 1);. Parênteses mantêm o significado, então await (load()?) aplica o ? à própria promise, o que é recusado com um help que aponta para await load()?. Um await também pode ser o sujeito de um match ou de um if, ou o argumento de uma chamada, inclusive dentro de um laço.

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

Tratamento inline de falhas ​

onfail é uma guarda terminal anexada ao inicializador de um const ou let simples. Ela trata Result<T, E>, uma Promise<Result<T, E>> aguardada, uma chamada direta com um único efeito throws E declarado ou uma rejeição aguardada. O nome declarado é o erro dentro do handler e o valor de sucesso depois dele. Um handler nunca continua com um valor substituto: ele sai com return, throw, continue ou break, e chegar ao seu fim sai por ele, retornando de uma função void, retornando Err(name) de uma função que retorna Result<U, E> com o mesmo tipo de erro ou propagando a exceção permitida. Numa função que retorna qualquer outro tipo, o handler precisa sair explicitamente (E0277).

tyrus
function render(): Result<void, string> {
    const result = loadUser() onfail {
        printError(result);
    };

    print(result.name);
    return Ok();
}

Sobre um Result aguardado, o Err é separado depois do await, então a mesma guarda trata as falhas dos módulos nativos. O handler em si executa sem suspender, e um await dentro dele é recusado (E3002).

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

Use try/catch para várias operações protegidas, recuperação com valor substituto ou um bloco finally. Um finally externo ainda executa exatamente uma vez quando um handler de onfail termina.

Tipos de objeto ​

tyrus
interface Account {
    id: i64;
    email: string;
    displayName?: string;
}

const account: Account = {
    id: 1,
    email: "[email protected]",
};

Literais de objeto são checados estruturalmente contra declarações de interface. Campos opcionais são acessados como valores opcionais.

Arrays e tuplas ​

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

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

tyrus
let xs: i32[] = Array.withCapacity(100);
// xs.length == 0, xs.capacity == 100

xs.push(1);
// xs.length == 1, xs.capacity == 100 (no reallocation)

Arrays guardam um tipo de elemento repetido. Tuplas guardam uma forma fixa com um tipo conhecido por posição.

Use [valor; tamanho] para criar um array onde todos os elementos são iguais ao valor informado. O tamanho deve ser um inteiro constante conhecido em tempo de compilação. Tipos Copy (inteiros, booleanos) e não-Copy (strings, arrays aninhados) são suportados; elementos não-Copy são clonados profundamente para cada posição.

Use Array.withCapacity(n) para criar um array vazio com buffer pré-alocado. O tipo do elemento é inferido pela anotação na variável. Isso evita realocações repetidas quando você sabe aproximadamente quantos elementos vai inserir.

Construtores de tipos genéricos ​

Use brackets angulares para fornecer argumentos de tipo a construtores de tipo nomeados. Array<T> equivale a T[], e Tuple<T, ...> equivale a [T, ...]; escolha a forma que deixa o tipo ao redor mais fácil de ler.

FormaArgumentosSignificado
Array<T>umUma sequência mutável ou imutável de T; equivale a T[].
Tuple<T, ...>zero ou maisUma sequência de tamanho fixo com um tipo por posição; equivale a [T, ...].
Optional<T>umUm valor que pode estar ausente; equivale a T?.
Range<T>umUm range numérico produzido por a..b ou a..=b.
Set<T>umUma coleção de valores únicos de T.
Map<K, V>doisUma coleção indexada de K para V.
Record<K, V>doisUm objeto com chaves K e valores V; Record<string, V> é um map dinâmico.
Promise<T>umO resultado de trabalho assíncrono que resolve para T.

Os utilitários de tipo de objetos também são genéricos: 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> e Parameters<T>. Consulte Coleções, Objetos e interfaces e Async e Await para operações e restrições.

Tipos de função ​

tyrus
function double(value: i32): i32 {
    return value * 2;
}

const predicate: (value: i32) 
    => boolean = (value: i32): boolean 
    => value > 10;

Assinaturas de função incluem tipos de parâmetros e retorno. O compilador usa essas assinaturas para checagem de chamadas, completion, hover e signature help.

Tipos de função se compõem com outros construtos de tipo:

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

Funções podem ser armazenadas em arrays e maps, habilitando registries de callbacks e sistemas de eventos:

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

Parênteses agrupam um tipo, então um array de tipo função pode ser escrito na forma inline em vez de só através de um alias:

tyrus
type Mapper = (n: i32) => i32;

const viaAlias: Mapper[] = [double, triple];
const inline: ((n: i32) => i32)[] = [double, triple];

const grouped: (i32)[] = [1, 2, 3];

O que separa um grupo de uma lista de parâmetros é a seta, e ela só é legível depois do parêntese de fechamento: (n: i32) => i32 é um tipo função, (i32)[] é um array de i32. Um grupo contém um tipo só, sem nome e sem ...; qualquer outra coisa é lista de parâmetros e continua exigindo a seta.

Um tipo de função pode declarar o que a função pode lançar: (string) => i32 throws string. Uma chamada através de um valor desse tipo precisa capturar ou propagar esses erros, como uma chamada direta, e uma função que lança não pode ser usada onde o tipo de função não os declara (E3298). Uma função async reporta seus erros como rejeição, então cabe num tipo de função sem throws.

tyrus
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, ""));
};