Ownership e Borrowing
Tyrus aplica regras de ownership em tempo de compilação, mantendo uma sintaxe concisa.
Move e Copy
Valores non-Copy como string movem em atribuição. O binding original fica inválido depois do 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 e boolean são Copy e continuam utilizáveis depois da atribuição.
const score: i32 = 10;
const backup: i32 = score;
print(score); // 10
print(backup); // 10Chamadas de função passam argumentos read-only sem consumir bindings comuns non-Copy do chamador, mantendo APIs usuais concisas. Referências explícitas estão disponíveis quando uma API precisa expor borrowing.
Borrowing
const original: string = "tyrus";
const borrowed: &string = &original;
print(borrowed); // "tyrus"
let counter: i32 = 0;
const mutable: &mut i32 = &mut counter;Um empréstimo pode tomar uma parte do valor: &basket.label empresta o campo. A referência lê através de basket, então é basket que fica emprestado, e atribuir a ele enquanto a referência está viva é recusado. Emprestar dois campos diferentes ao mesmo tempo é recusado pelo mesmo motivo, o que é mais restrito do que precisaria ser e nunca está errado.
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);
// fruitVocê pode ter vários borrows imutáveis ou um borrow mutável, nunca ambos ao mesmo tempo. Borrows temporários terminam no fim do statement. Um borrow armazenado termina no último ponto em que seu binding é mencionado, não na chave de fechamento: assim que nada mais lê a referência, o valor apontado fica livre para ser atribuído, emprestado de forma mutável ou movido, mesmo com o binding ainda em escopo. Uma menção dentro do corpo de um laço ou capturada por uma closure conta, e mantém o borrow vivo enquanto aquela construção puder executar. Uma menção dentro de um corpo de defer ou errdefer mantém o borrow vivo até a chave de fechamento, onde quer que o finalizador esteja escrito, porque é ali que ele roda. Referências não podem viver mais que o valor para o qual apontam.
Dentro de uma função async um empréstimo se comporta do mesmo jeito, com uma regra a mais: ele não pode continuar vivo num await. Segurar um através de uma suspensão é rejeitado, "borrow b of a crosses await", e é justamente isso que torna empréstimos baratos ali, já que a máquina de estados guarda os bytes emprestados no frame dela e não libera nenhum deles.
Non-Lexical Lifetimes (NLL)
O Tyrus implementa Non-Lexical Lifetimes (NLL). Em vez de manter os empréstimos ativos até a chave de fechamento do bloco léxico (}), o borrow checker constrói um Grafo de Fluxo de Controle (CFG) e utiliza análise de liveness retroativa (backward) para liberar empréstimos imediatamente após seu último uso real.
Empréstimo Mutável Seguido de Mutação
Um empréstimo mutável libera a variável original assim que a referência não é mais lida:
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
};Sem NLL, r permaneceria ativo até o final do bloco léxico, rejeitando x += 1.
Empréstimos Dentro de Branches Condicionais
Empréstimos realizados dentro de um bloco if expiram quando o branch termina ou cessa de utilizá-los, liberando a variável no escopo externo:
let x: i32 = 5;
if (cond) {
const r: &i32 = &x;
print(r); // `r` dies here
}
x += 1; // OK: no active borrow in outer scopeMove Após Empréstimo
Assim que uma referência emprestada não for mais acessada, o valor original pode ser movido ou consumido 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 movedReatribuição de Referências
Reatribuir uma referência mutável a um novo alvo libera imediatamente o empréstimo sobre o alvo 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);Prevenção de Escape de Referências
O NLL encurta tempos de vida onde é seguro; ele nunca estende o tempo de vida além do valor original. Retornar ou armazenar referências a variáveis locais cujo escopo encerra continua estritamente proibido:
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 não tem undefined, e código de usuário não deve usar null como inicializador normal. Valores nullable usam T?, campos opcionais, parâmetros opcionais, fronteiras externas, narrowing e ??.
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!) é intencionalmente desencorajado e diagnosticado pelo tooling da linguagem; prefira narrowing explícito ou valores fallback.
Inicialização Adiada
const score: i32 = 85;
let label: string;
if (score >= 90) {
label = "A";
} else {
label = "B";
}
print(label); // "B"O compilador roda definite-assignment analysis e rejeita leitura de um binding let x: T; antes de todo caminho atribuí-lo. Bindings const devem ser inicializados onde são declarados.
