Ownership y préstamos

Forja incorpora los conceptos de ownership (propiedad) y préstamos (borrowing) de Rust, adaptados al español. Este sistema previene errores de memoria sin necesidad de un garbage collector, verificando las reglas en tiempo de compilación.

🔥 Idea central: Cada valor tiene un único dueño. Cuando asignás una variable a otra, la propiedad se transfiere (move). Si solo querés prestarla, usá &.

Mutabilidad básica

Lo más simple: las variables mutables se pueden modificar, las constantes no:

✅ vs ❌

variable contador = 0
contador = contador + 1   // ✅ OK: es mutable

constante maximo = 100
// maximo = 200  // ❌ ErrorDePropiedad: es inmutable

Referencias con `&`

El operador & crea una referencia (préstamo) a una variable. La variable original retiene la propiedad:

🔗 Préstamo (referencia)

variable x = 42
variable ref = &x       // préstamo: ref toma prestado x
escribir(x)              // ✅ x sigue siendo el dueño

Préstamo mutable con `&mut`

Si necesitás modificar un valor prestado, usá un préstamo mutable:

📝 Préstamo mutable

variable x = 42
variable ref = &mut x    // préstamo mutable
// ref puede modificar x temporalmente

Parámetro `prestado`

Indica que un parámetro de función se recibe por referencia, no por valor. Así la variable original no se mueve (no pierde ownership):

📥 Referencia inmutable

funcion mostrar(prestado valor) {
    escribir("El valor es: " + valor)
}

variable dato = 100
mostrar(dato)                          // presta dato a la función
escribir("Dato sigue disponible: " + dato)  // ✅ sigue vivo

💡 Sin prestado: Si el parámetro no lleva prestado, el valor se mueve a la función y la variable original ya no se puede usar.

Préstamo mutable con `prestado mut`

Si además de prestar necesitás que la función modifique el valor, usá prestado mut. Equivale a &mut T en Rust:

📥 Referencia mutable

funcion duplicar(prestado mut valor) {
    valor = valor * 2    // se puede modificar
}

variable x = 5
duplicar(&mut x)                     // pasamos &mut explicitamente
escribir(x)                           // right-arrow 10

⚠️ Cuando usás prestado mut, la llamada debe pasar una referencia mutable explícita con &mut. No podés tener otros préstamos activos mientras exista un préstamo mutable.

Errores que previene el Borrow Checker

Error	Qué detecta
Variable no declarada	Usar una variable antes de crearla
Modificar inmutable	Asignar a una `constante` o variable no-mut
Variable movida	Usar variable después de transferir su ownership
Préstamo inválido	Prestar una variable que ya fue movida
Modificar con préstamos activos	Escribir en variable que tiene referencias activas
Ambigüedad de ámbitos	Variables que se solapan en scopes anidados

Ejemplo completo

📄 ownership

// Mutabilidad
variable contador = 0
contador = contador + 1
escribir("Contador: " + contador)

// Referencias y préstamos
variable x = 42
variable ref = &x
escribir("Valor de x: " + x)

// Función con parámetro prestado
funcion mostrar(prestado valor) {
    escribir("El valor es: " + valor)
}

variable dato = 100
mostrar(dato)
escribir("Dato sigue disponible: " + dato)

Equivalencia con Rust

Forja	Rust
`variable x = 5`	`let mut x = 5;`
`constante x = 5`	`let x = 5;`
`&x`	`&x`
`&mut x`	`&mut x`
`prestado param`	`param: &Tipo`
`prestado mut param`	`param: &mut Tipo`

⚠️ Estado actual: El Borrow Checker de Forja está operativo para verificar declaración de variables, mutabilidad y ámbitos. El tracking completo de movimientos (move) para tipos no-Copy está en desarrollo activo. La keyword prestado en parámetros de función habilita el borrowing explícito.

Ownership y préstamos

Mutabilidad básica

Referencias con &

Préstamo mutable con &mut

Parámetro prestado