Esta traducción fue asistida por IA y revisada superficialmente. Si encuentras errores o algo no suena natural, escríbeme - lo agradezco.
Ya has declarado variables antes. Les diste un nombre, asignaste un valor, las usaste. Dónde vivían exactamente en memoria - en qué superficie, en qué lugar - no era tu preocupación. La mayoría de los lenguajes no te piden que te importe.
Rust tampoco te pide que lo gestiones. Pero espera que conozcas la habitación.
El escritorio y el tablero
Estás sentado ante un escritorio. La superficie frente a ti es limitada - espacio para unas pocas cosas. Sus tamaños son conocidos de antemano: un libro, un bolígrafo (seguirán siendo del mismo tamaño todo el tiempo). Cuando este espacio ya no se necesita, lo barres todo de una vez. No retiras las cosas una a una.
Detrás de ti, un gran tablero de corcho está montado en la pared. Tiene mucho más espacio que el escritorio. Lo que está fijado allí está hecho de partes: un manojo de llaves, una colección de medallas. Puedes añadir o quitar una llave o una medalla cuando lo necesites. Para cada uno de esos objetos tienes un pequeño papel en el escritorio (llaves - esquina inferior derecha, medallas
- en el centro). Lo que el papel señala puede ser de cualquier tamaño. Y cuando retiras ese papel del escritorio, también tienes que descolgar del tablero lo que señalaba. No es un solo gesto - hay que desprender eso del tablero por separado.
El escritorio es el stack. El tablero es el heap.
El modelo que casi funciona
El modelo habitual: una variable contiene un valor. count contiene 5. name contiene
"Alice". Ese modelo es correcto hasta cierto punto - y te lleva lejos.
Se rompe cuando los tipos empiezan a comportarse de manera diferente entre sí. ¿Por qué asignar
un entero a otra variable deja el original intacto, mientras que asignar un String lo mueve?
¿Por qué uno se copia libremente y el otro no?
La respuesta no está en el sistema de tipos. Está en el escritorio.
En el escritorio, en el tablero
let id: u32 = 1; // cuatro bytes, en el escritorio
let title = String::from("Buy coffee"); // papel en el escritorio - texto fijado al tableroid vive directamente en el escritorio. Cuatro bytes, tamaño conocido antes de ejecutar el
programa. Cuando este ámbito termina, se limpia junto con todo lo demás. Copiarlo significa
escribir los mismos cuatro bytes en otro papel: trivial. Rust lo hace automáticamente.
title no es lo que parece. El texto "Buy coffee" vive en el tablero - fijado allí porque un
String puede crecer, y su tamaño final no se conoce en tiempo de compilación. Lo que está en el
escritorio es un pequeño papel con tres datos: dónde en el tablero está fijado el texto, cuántos
bytes se usan ahora y cuántos puede contener el espacio antes de necesitar uno mayor.
Copiar title costaría demasiado - habría que duplicar la chincheta y el texto mismo. Rust no
oculta ese coste. Cuando asignas title a una nueva variable, simplemente entregas el papel -
solo el pequeño papel se mueve, no lo que está fijado en el tablero. El papel se ha ido. Rust no
te dejará usar el original.
El valor no está donde está la variable.
Cuando title sale del ámbito, Rust retira la chincheta del tablero y recupera el espacio. Sin
ninguna acción requerida - porque title era quien sostenía el papel, y ya no existe.
Ahora todo encaja
La mayor parte del tiempo no pensarás en esto. String, Vec, Box - valores que viven en el
tablero - se comportan con naturalidad. Rust gestiona las chinchetas.
Ahora el movimiento tiene sentido. Pasarlo es pasar esa responsabilidad. No había nada que copiar.
Pero un pergamino más adelante encontrarás el verificador de préstamos. Hablará de referencias que no pueden sobrevivir a lo que señalan, y de accesos conflictivos al mismo lugar. El tablero que está vigilando es el mismo que tienes detrás. Las chinchetas que rastrea son las que acabas de aprender.
Cuando lleguen los mensajes de error, apuntarán a lugares que ahora tienen sentido.
Vale la pena saber una cosa más: hay más de dos lugares. Los literales de cadena - antes de
convertirse en un String - viven en memoria estática, integrada en el binario compilado. El
código ejecutable del programa también vive allí. Ninguno cambia en tiempo de ejecución, y Rust
no te pide que gestiones ninguno de ellos. Para entender la propiedad y el verificador de
préstamos, el escritorio y el tablero son el mapa que necesitas.