Rust es un lenguaje de programación compilado, de propósito general y multiparadigma que está siendo desarrollado por Mozilla y ha sido diseñado para ser ‘un lenguaje seguro, concurrente y práctico. soporta programación funcional, por procedimientos, imperativa y orientada a objetos. Rust se enfoca principalmente en seguridad, velocidad y concurrencia.
El lenguaje surgió de un proyecto personal desarrollado por Graydon Hoare (trabajador de Mozilla), quién empezó a trabajar en él en 2006 y Mozilla se involucró en este proyecto en 2009, dandose a conocer oficialmente en 2010.
El objetivo de Rust es ser un buen lenguaje para la creación de grandes programas del lado del cliente y del servidor que se ejecuten en Internet. Esto ha llevado a un conjunto de características con un énfasis en la seguridad, el control de distribución de la memoria y la concurrencia.
Rust también implementa ‘abstracciones con cero costo’, abstracciones que se sienten como las de un lenguaje de alto nivel. Aun así, Rust permite control preciso tal y como un lenguaje de bajo nivel lo haría.
un ejemplo de un programa que muestra la frase “Hola Mundo!” en Rust sería:
fn main() {
println("Hola Mundo!");
}
La sintaxis de Rust es similar a la de C y C++, con bloques de código delimitados por llaves y estructuras de control de flujo tales como if, else, do, while y for
El concepto principal que hace único a Rust es llamado “pertenencia” (“ownership”). por ejemplo:
fn main() {
let mut x = vec!["Hola", "mundo"];
}
Según este código:
- El programa crea un una variable llamada x.
- El valor de esta variable es Vec<T>, un “vector”, que creamos a través de una macro definida en la biblioteca estandar.
- Las macros son invocadas con un !
- Las macros pueden hacer cosas más complejas que solo llamadas a funciones, por tal razon son visualmente distintas.
- La definición mut es para hacer x mutable: En Rust las variables son inmutables por defecto.
Agregando otra línea:
fn main() {
let mut x = vec!["Hola", "mundo"];
let y = &x[0];
}
- Se agregó la variable como una “referencia” a el primer elemento de el vector
- Las referencias en Rust son similares a los punteros en otros lenguajes
- Las referencias interactuan con el sistema de pertenencia a través de el “préstamo” (“borrowing”), ellas toman prestado a lo que apuntan, en vez de adueñarse de ello.
fn main() {
let mut x = vec!["Hola", "mundo"];
let y = &x[0];
x.push("foo");
}
- Push es un metodo en los vectores que agrega un elemento al final del vector.
- Esta ultima linea x.push(“foo”) causará un error debido a que si hacemos la variable mutable no podemos llamar a push ya que tenemos una referencia a un elemento del vector y.
para resolver este problema hay dos opciones:
clonar el valor de x en vez de una referencia
fn main() {
let mut x = vec!["Hola", "mundo"];
let y = x[0].clone();
x.push("foo");
}
Si necesitamos una referencia, hay que asegurarse que la referencia salga de ámbito antes que tratemos de hacer la mutación:
fn main() {
let mut x = vec!["Hola", "mundo"];
{
let y = &x[0];
}
x.push("foo");
}
Con el par adicional de llaves hemos creado un ámbito interno. y saldrá de ámbito antes que llamemos a push(), entonces no hay problema. Este concepto de pertenencia no es solo bueno para prevenir punteros colgantes, sino un conjunto entero de problemas, como invalidación de iteradores, concurrencia y más.
Existen muchas mas cosas por conocer y descubrir en Rust, por lo cual esperamos que esta introducción sirva para despertar la curiosidad sobre este lenguaje de programación.
Referencias:
https://www.gitbook.com/book/goyox86/el-libro-de-rust/details
https://es.wikipedia.org/wiki/Rust_(lenguaje_de_programaci%C3%B3n)
https://www.rust-lang.org/en-US/