Variables y constantes

Forja distingue entre variables (mutables, se pueden reasignar) y constantes (inmutables, no se pueden modificar). Esto refleja el sistema de mutabilidad de Rust pero con palabras en español.

🔥 Regla de oro: variable = let mut en Rust. constante = let en Rust.

`variable` — Mutable

Las variables se pueden reasignar cuantas veces quieras:

📝 Reasignación permitida

variable nombre = "Gaucho"
variable edad = 30

// ✅ Reasignación permitida
edad = 31
nombre = "Otro nombre"

`constante` — Inmutable

Las constantes no pueden modificarse después de su declaración:

📝 No se puede reasignar

constante altura = 1.85
constante pais = "Argentina"

// ❌ Error: No se puede modificar una constante
// altura = 2.0  → ErrorDePropiedad

Con tipo explícito

Podés declarar el tipo después del nombre con : Tipo:

📝 Tipado explícito

variable nombre: Texto = "Gaucho"
variable edad: Entero = 30
variable altura: Decimal = 1.85
constante activo: Booleano = verdadero

Sin valor inicial

Podés declarar una variable sin asignarle valor, aunque necesitás especificar el tipo:

📝 Declaración sin inicialización

variable mensaje: Texto = ""
variable contador = 0

💡 Forja infiere el tipo automáticamente. Solo necesitás especificarlo cuando no hay valor inicial o cuando querés forzar un tipo distinto al inferido.

Reasignación de variables

Una vez declarada con variable, podés cambiar su valor con el operador =:

📝 Reasignación

variable contador = 0
contador = 10            // ✅ Reasignación permitida
contador = contador + 1  // ✅ Se puede reasignar con expresiones

constante maximo = 100
// maximo = 200  → ErrorDePropiedad (❌ constante es inmutable)

⚠️ Solo las variables declaradas con variable pueden reasignarse. Las declaradas con constante son inmutables.

Asignación múltiple

Podés declarar varias variables de una sola vez separándolas con comas. Todas comparten la misma mutabilidad y el mismo valor inicial:

📝 Múltiples variables

variable a, b = 0          // a = 0, b = 0 (ambas mutables)
constante x, y = 10        // x = 10, y = 10 (ambas inmutables)
variable m, n = leer()    // ambas reciben el mismo valor de entrada

💡 Es útil para inicializar varias variables al mismo valor, o para recibir el mismo resultado en múltiples variables.

Destructuring (asignación por patrón)

Forja permite declarar variables destructuring (desestructurando) tuplas y arreglos en una sola línea. Especialmente útil con funciones que retornan múltiples valores como canal().

Con tuplas `variable (x, y) = expr`

📦 Destructuring de tupla

// canal() retorna (emisor, receptor)
variable (tx, rx) = canal()

// También funciona con tuplas literales
variable (nombre, edad) = ("Ana", 30)

Con arreglos `variable [a, b] = expr`

📦 Destructuring de arreglo

variable [primero, segundo] = [1, 2, 3]
// primero = 1, segundo = 2

💡 El destructuring con tuplas se usa frecuentemente con canal() para obtener el emisor y receptor en una sola línea.

Referencias a variables (`&` y `&mut`)

Forja permite crear referencias (préstamos) a variables usando el operador &. Esto permite acceder al valor sin transferir la propiedad (ownership):

🔗 Préstamo inmutable (&)

variable x = 42
variable ref = &x        // referencia (préstamo) a x
escribir(x)               // ✅ x sigue siendo el dueño
escribir(ref)             // ✅ se puede leer via la referencia

🔗 Préstamo mutable (&mut)

variable x = 42
variable ref = &mut x    // préstamo mutable
ref = 100                 // ✅ se puede modificar a través de la referencia
// x = 50  → ❌ Error si hay préstamos activos

⚠️ Reglas de préstamos: Podés tener múltiples referencias inmutables (&) O una única referencia mutable (&mut), pero no ambas a la vez. El Borrow Checker verifica estas reglas en tiempo de compilación.

📖 Más información: Consultá la página de Ownership y préstamos para entender el sistema completo de ownership, el keyword prestado en parámetros, y las reglas del Borrow Checker.

El keyword `mut` en parámetros

El keyword mut se usa junto con prestado en los parámetros de función para indicar un préstamo mutable (&mut T en Rust):

📝 Parámetro prestado mutable

funcion incrementar(prestado mut valor) {
    valor = valor + 1   // ✅ se puede modificar porque es prestado mut
}

variable x = 5
incrementar(&mut x)     // pasamos una referencia mutable
escribir(x)              // → 6

Combinaciones posibles de parámetros:

Sintaxis	Equivalente Rust	Descripción
`nombre`	`nombre: T`	Por valor (ownership se transfiere)
`prestado nombre`	`nombre: &T`	Referencia inmutable
`prestado mut nombre`	`nombre: &mut T`	Referencia mutable

Equivalencia con Rust

Esta tabla te muestra cómo se traduce cada declaración de Forja a Rust:

Forja	Rust generado
`variable x = 5`	`let mut x = 5;`
`constante x = 5`	`let x = 5;`
`variable x: Entero = 5`	`let mut x: i64 = 5;`
`constante x: Texto = "a"`	`let x: String = String::from("a");`
`variable a, b = 0`	`let mut a = 0; let mut b = 0;`
`variable (tx, rx) = canal()`	`let (mut tx, mut rx) = channel();`
`&x`	`&x`
`&mut x`	`&mut x`
`prestado param`	`param: &Tipo`
`prestado mut param`	`param: &mut Tipo`

⚠️ Diferencia clave con Rust: En Rust las variables son inmutables por defecto. Forja invierte esto: variable es mutable, constante es inmutable. Esto es más intuitivo para quienes están aprendiendo.

Variables y constantes

variable — Mutable

constante — Inmutable