Ownership y Borrowing
Tyrus aplica reglas de ownership en tiempo de compilación con una sintaxis concisa.
Move y Copy
Valores non-Copy como string se mueven en asignación. El binding original queda inválido después del move.
error
const greeting: string = "hello";
const copy: string = greeting;
print(copy); // hello
print(greeting); error
error[E0382]: use of moved value: `greeting`
at /src/main.tyr:4:7
print(greeting);
^^^^^^^^
at /src/main.tyr:2:22
const copy: string = greeting;
^^^^^^^^ value moved here; borrow `greeting` instead if it must remain usable
help: borrow `greeting` at the move site if it must remain usable later
help: for example: `const copy: &string = &greeting;`Valores primitivos como i32, i64, f32, f64 y boolean son Copy y siguen siendo utilizables después de la asignación.
const score: i32 = 10;
const backup: i32 = score;
print(score); // 10
print(backup); // 10Las llamadas de función pasan argumentos read-only sin consumir bindings comunes non-Copy del llamador, manteniendo API concisas. Las referencias explícitas están disponibles cuando una API necesita exponer borrowing.
Borrowing
const original: string = "tyrus";
const borrowed: &string = &original;
print(borrowed); // "tyrus"
let counter: i32 = 0;
const mutable: &mut i32 = &mut counter;Un préstamo puede tomar una parte del valor: &basket.label presta el campo. La referencia lee a través de basket, así que es basket lo que queda prestado, y asignarle mientras la referencia está viva se rechaza. Prestar dos campos distintos a la vez se rechaza por el mismo motivo, lo que es más estricto de lo necesario y nunca es incorrecto.
interface Basket {
label: string;
items: i32[];
}
const describe = (value: &string): void => {
console.log(value);
};
const basket: Basket = { label: "fruit", items: [1, 2, 3] };
describe(&basket.label);
// fruitPuedes tener muchos borrows inmutables o un borrow mutable, nunca ambos al mismo tiempo. Los borrows temporales terminan al final del statement. Un borrow almacenado termina en el último punto en que su binding es mencionado, no en la llave de cierre: en cuanto nada vuelve a leer la referencia, el valor apuntado queda libre para ser asignado, prestado de forma mutable o movido, aunque el binding siga en scope. Una mención dentro del cuerpo de un bucle o capturada por una closure cuenta, y mantiene el borrow vivo mientras esa construcción pueda ejecutarse. Una mención dentro de un cuerpo de defer o errdefer mantiene el borrow vivo hasta la llave de cierre, dondequiera que esté escrito el finalizador, porque ahí es donde se ejecuta. Las referencias no pueden vivir más que el valor al que apuntan.
Dentro de una función async un préstamo se comporta igual, con una regla más: no puede seguir vivo en un await. Sostener uno a través de una suspensión se rechaza, "borrow b of a crosses await", y eso es justamente lo que hace baratos los préstamos ahí, ya que la máquina de estados guarda los bytes prestados en su frame y no libera ninguno.
Non-Lexical Lifetimes (NLL)
Tyrus implementa Non-Lexical Lifetimes (NLL). En lugar de mantener los préstamos activos hasta la llave de cierre del bloque léxico (}), el borrow checker construye un Grafo de Flujo de Control (CFG) y utiliza análisis de liveness retrógrado (backward) para liberar préstamos inmediatamente después de su último uso real.
Préstamo Mutable Seguido de Mutación
Un préstamo mutable libera la variable original tan pronto como la referencia ya no se lee:
const main = (): void => {
let x: i32 = 5;
const r: &mut i32 = &mut x;
print(r); // last use of `r`
x += 1; // OK: `r` is dead, so `x` can be mutated
};Sin NLL, r permanecería activo hasta el final del bloque léxico, rechazando x += 1.
Préstamos Dentro de Ramas Condicionales
Los préstamos tomados dentro de un bloque if expiran cuando la rama termina o deja de utilizarlos, liberando la variable en el scope exterior:
let x: i32 = 5;
if (cond) {
const r: &i32 = &x;
print(r); // `r` dies here
}
x += 1; // OK: no active borrow in outer scopeMove Después de Préstamo
Tan pronto como una referencia prestada ya no se accede, el valor original se puede mover o consumir normalmente:
const consume = (data: string[]): void => {};
const s: string[] = ["tyrus"];
const r: &string[] = &s;
print(r[0]); // last use of `r`
consume(s); // OK: borrow ended, `s` can be movedReasignación de Referencias
Reasignar una referencia mutable a un nuevo destino libera de inmediato el préstamo sobre el destino anterior:
let a: i32 = 1;
let b: i32 = 2;
let r: &mut i32 = &mut a;
print(r);
r = &mut b; // borrow on `a` ends; borrow on `b` begins
a += 1; // OK: `a` is no longer borrowed
print(r);Prevención de Escape de Referencias
NLL solo acorta tiempos de vida donde es seguro; nunca extiende el tiempo de vida más allá del valor original. Retornar o almacenar referencias a variables locales cuyo scope termina sigue estando estrictamente prohibido:
error
const invalidEscape = (): &i32 => {
const x: i32 = 42;
return &x;
};error
error[E0500]: cannot return reference to local variable `x`
at /src/main.tyr:3:12
return &x;
^^
help: references cannot outlive the value they point to; return an owned value insteadValores Nullable
tyrus no tiene undefined, y el código de usuario no debe usar null como inicializador normal. Los valores nullable usan T?, campos opcionales, parámetros opcionales, fronteras externas, narrowing y ??.
interface Profile {
nickname?: string;
}
const profile: Profile = {};
const nickname: string? = profile.nickname;
const fallback: string = nickname ?? "anonymous"; // "anonymous"
if (nickname) {
const present: string = nickname;
print(present); // "nickname value"
}Forced unwrap (value!) se desalienta intencionalmente y es diagnosticado por el tooling del lenguaje; prefiere narrowing explícito o valores fallback.
Inicialización Diferida
const score: i32 = 85;
let label: string;
if (score >= 90) {
label = "A";
} else {
label = "B";
}
print(label); // "B"El compilador ejecuta definite-assignment analysis y rechaza leer un binding let x: T; antes de que todos los caminos lo asignen. Los bindings const deben inicializarse donde se declaran.
