Funções, Closures e Generics
Tyrus oferece arrow functions e valores de função nativos.
Funções
const add = (left: i32, right: i32): i32 => {
return left + right;
};
const double = (n: i32): i32 => n * 2;
const greet = (name: string): void => {
print("hello");
print(name); // "name value"
};Assinaturas de função incluem tipos de parâmetros e retorno. Corpos de expressão retornam implicitamente. Uma função non-void deve retornar um valor em todo caminho alcançável.
Valores de Função
const double: (i32) => i32 = (value: i32): i32 => value * 2;
const result: i32 = double(21);Valores de função podem ser armazenados e chamados. Eles podem capturar valores lexicais, sujeitos às regras de ownership e lifetime.
Uma função nomeada é ela mesma um valor de primeira classe: pode ser passada como argumento, atribuída a outro binding e usada como callback de array. Um const nome = (…) => … no topo declara uma função nomeada, então o mesmo se aplica a ela.
const double = (value: i32): i32 => value * 2;
const apply = (f: (i32) => i32, v: i32): i32 => f(v);
print(apply(double, 21)); // passed as an argument
const numbers: i32[] = [1, 2, 3];
const doubled: i32[] = numbers.map(double); // used as a callbackUma função também pode retornar uma função. O valor retornado preserva seu tipo de função, então o binding que o recebe continua chamável sem anotação.
const makeAdder = (base: i32): (value: i32) => i32 => {
return (value: i32): i32 => base + value;
};
const add5 = makeAdder(5); // inferred as `(i32) => i32`
print(add5(3)); // 8A função retornada também pode ser chamada diretamente, sem um binding no meio. O callee passa a ser uma expressão, e não um nome, então não carrega assinatura para consultar: o tipo dele é o contrato inteiro, e chamar algo que não é valor de função dá E0618 com o range no callee.
print(makeAdder(5)(3)); // 8
print(makeUserFactory()().id);Captura de dois níveis ainda não é suportada
Uma closure que captura um binding de dois níveis acima, como em (a) => (b) => (c) => a + b + c, é rejeitada com E0435, ancorado na menção que alcança longe demais. Uma closure só pode capturar da função imediatamente ao redor dela.
Parâmetros Mutáveis
const increment = (mut n: i32): i32 => {
n += 1;
return n;
};mut permite reatribuição dentro do corpo da função sem tornar o binding do chamador mutável.
Parâmetros Rest
const sum = (...values: i32[]): i32 => {
let total: i32 = 0;
for (const value of values) {
total += value;
}
return total;
};
const numbers: i32[] = [1, 2, 3];
print(sum(1, 2, 3)); // individual arguments
print(sum(...numbers)); // spread of an array
print(sum()); // no argumentsUm parâmetro rest (...nome: T[]) precisa ser o último parâmetro e coleta os argumentos finais em um array. Ele aceita argumentos individuais, um ...spread de um array existente, nenhum argumento, e qualquer combinação junto de parâmetros fixos iniciais. Argumentos individuais são checados contra o tipo do elemento; um argumento spread é checado contra o tipo do array inteiro.
Closures
const factor: i32 = 3;
const offset: i32 = 2;
const transform: (i32) => i32 = (value: i32): i32 => value * factor + offset;
print(transform(10)); // 32Valores de função usam uma representação nativa de closure com ponteiro de função e ponteiro de ambiente. Callbacks síncronos de arrays funcionais podem capturar valores lexicais sem transferir ownership do recurso capturado.
O Que uma Captura Enxerga
Uma closure que nunca sai da função que a declarou captura os próprios bindings. Leituras enxergam o valor atual, escritas alcançam o binding de fora, e o estado acumula entre chamadas:
function main(): void {
let counter: i32 = 0;
const bump = (): i32 => {
counter = counter + 1;
return counter;
};
print(bump()); // 1
print(bump()); // 2
print(counter); // 2
}Uma closure só permanece dentro da sua função quando toda menção a ela é uma chamada. Retorná-la, passá-la como argumento, apelidá-la com outro nome ou guardá-la em qualquer lugar entrega o valor dela a algo que pode sobreviver à função, e aí os bindings que ela capturou já não existem quando ela roda.
Uma closure assim captura uma cópia, tirada no momento em que ela é construída. Ler uma cópia é bem definido. Escrever nela não serve para nada: a escrita cai na cópia, e nada de fora consegue observá-la. Isso é E0436, ancorado na própria escrita:
error
function make(): () => i32 {
let counter: i32 = 0;
return (): i32 => {
counter = counter + 1;
return counter;
};
}error[E0436]: cannot assign to `counter` from inside a closure that outlives its scope
at /src/main.tyr:4:9
counter = counter + 1;
^^^^^^^^^^^^^^^^^^^^^^
help: this closure escapes the function that declared `counter`, so it captures a copy; the write lands in that copy and nothing can observe it
help: return the value from the closure instead of writing `counter`, or hold the state in a `Mutex` both sides can reachTIP
A correção é devolver o valor em vez de escrevê-lo, ou guardar o estado compartilhado num Mutex que os dois lados alcancem. O segundo é o que uma task iniciada com spawn precisa, e a mesma regra é o que impede uma task de compartilhar estado mutável com o código que a iniciou.
Generics
const identity = <T>(value: T): T => value;
const first = <T extends string>(value: T): T => value;
const number: i32 = identity<i32>(42);
const message: string = identity("tyrus");
const constrained: string = first("native");Funções genéricas usam monomorfização nativa: o compilador emite uma especialização LLVM por combinação concreta de tipos. A substituição genérica funciona em arrays, referências, opcionais e tipos de função.
