Funciones, Closures y Generics
Tyrus ofrece arrow functions y valores de función nativos.
Funciones
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"
};Las firmas de función incluyen tipos de parámetros y retorno. Los cuerpos de expresión retornan implícitamente. Una función non-void debe retornar un valor en todo camino alcanzable.
Valores de Función
const double: (i32) => i32 = (value: i32): i32 => value * 2;
const result: i32 = double(21);Los valores de función pueden almacenarse y llamarse. Pueden capturar valores léxicos, sujetos a reglas de ownership y lifetime.
Una función nombrada es en sí misma un valor de primera clase: puede pasarse como argumento, asignarse a otro binding y usarse como callback de array. Un const nombre = (…) => … en el nivel superior declara una función nombrada, así que lo mismo aplica a ella.
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 callbackUna función también puede devolver una función. El valor devuelto conserva su tipo de función, por lo que el binding que lo recibe sigue siendo invocable sin anotación.
const makeAdder = (base: i32): (value: i32) => i32 => {
return (value: i32): i32 => base + value;
};
const add5 = makeAdder(5); // inferred as `(i32) => i32`
print(add5(3)); // 8La función devuelta también puede llamarse directamente, sin un binding intermedio. El callee pasa a ser una expresión, y no un nombre, así que no lleva una firma que consultar: su tipo es el contrato completo, y llamar algo que no es un valor de función da E0618 con el rango en el callee.
print(makeAdder(5)(3)); // 8
print(makeUserFactory()().id);La captura de dos niveles aún no está soportada
Una closure que captura un binding de dos niveles arriba, como en (a) => (b) => (c) => a + b + c, es rechazada con E0435, anclado en la mención que llega demasiado lejos. Una closure solo puede capturar de la función inmediatamente alrededor de ella.
Parámetros Mutables
const increment = (mut n: i32): i32 => {
n += 1;
return n;
};mut permite reasignación dentro del cuerpo de la función sin volver mutable el binding del llamador.
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 argumentsUn parámetro rest (...nombre: T[]) debe ser el último parámetro y recolecta los argumentos finales en un array. Acepta argumentos individuales, un ...spread de un array existente, ningún argumento, y cualquier combinación junto a parámetros fijos iniciales. Los argumentos individuales se comprueban contra el tipo del elemento; un argumento spread se comprueba contra el tipo del array completo.
Closures
const factor: i32 = 3;
const offset: i32 = 2;
const transform: (i32) => i32 = (value: i32): i32 => value * factor + offset;
print(transform(10)); // 32Los valores de función usan una representación nativa de closure con puntero de función y puntero de entorno. Callbacks síncronos de arrays funcionales pueden capturar valores léxicos sin transferir ownership del recurso capturado.
Qué Ve una Captura
Una closure que nunca sale de la función que la declaró captura los bindings mismos. Las lecturas ven el valor actual, las escrituras alcanzan el binding de afuera, y el estado se acumula entre llamadas:
function main(): void {
let counter: i32 = 0;
const bump = (): i32 => {
counter = counter + 1;
return counter;
};
print(bump()); // 1
print(bump()); // 2
print(counter); // 2
}Una closure solo permanece dentro de su función cuando toda mención a ella es una llamada. Devolverla, pasarla como argumento, aliasarla con otro nombre o guardarla en cualquier lugar entrega su valor a algo que puede sobrevivir a la función, y entonces los bindings que capturó ya no existen cuando ella corre.
Una closure así captura una copia, tomada en el momento en que se construye. Leer una copia está bien definido. Escribirla no sirve de nada: la escritura cae en la copia, y nada de afuera puede observarla. Eso es E0436, anclado en la escritura misma:
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
La corrección es devolver el valor en lugar de escribirlo, o guardar el estado compartido en un Mutex que ambos lados alcancen. Lo segundo es lo que necesita una task iniciada con spawn, y la misma regla es lo que impide que una task comparta estado mutable con el código que la inició.
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");Las funciones genéricas usan monomorfización nativa: el compilador emite una especialización LLVM por combinación concreta de tipos. La sustitución genérica funciona en arrays, referencias, opcionales y tipos de función.
