Skip to content

Funções, Closures e Generics ​

Tyrus oferece arrow functions e valores de função nativos.

Funções ​

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

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

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

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

tyrus
const makeAdder = (base: i32): (value: i32) => i32 => {
    return (value: i32): i32 => base + value;
};

const add5 = makeAdder(5); // inferred as `(i32) => i32`
print(add5(3)); // 8

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

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

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

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

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

tyrus
const factor: i32 = 3;
const offset: i32 = 2;
const transform: (i32) => i32 = (value: i32): i32 => value * factor + offset;
print(transform(10)); // 32

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

tyrus
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

tyrus
function make(): () => i32 {
    let counter: i32 = 0;
    return (): i32 => {
        counter = counter + 1; 
        return counter;
    };
}
text
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 reach

TIP

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 ​

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