Skip to content

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

tyrus
const greeting: string = "hello";
const copy: string = greeting;

print(copy); // hello
print(greeting); 

error

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

tyrus
const score: i32 = 10;
const backup: i32 = score;
print(score); // 10
print(backup); // 10

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

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

tyrus
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);
// fruit

Você 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:

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

tyrus
let x: i32 = 5;
if (cond) {
    const r: &i32 = &x;
    print(r); // `r` dies here
}
x += 1; // OK: no active borrow in outer scope

Move Após Empréstimo ​

Assim que uma referência emprestada não for mais acessada, o valor original pode ser movido ou consumido normalmente:

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

Reatribuição de Referências ​

Reatribuir uma referência mutável a um novo alvo libera imediatamente o empréstimo sobre o alvo anterior:

tyrus
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

tyrus
const invalidEscape = (): &i32 => {
    const x: i32 = 42;
    return &x; 
};

error

text
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 instead

Valores 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 ??.

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

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