El lenguaje de programación Rust

by davidgb | Ago 19, 2016 | blog, Sin categoría

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/