Rust (lenguaje de programación)

Rust
Desarrollador(es)
Desarrolladores del proyecto Rust https://www.rust-lang.org/fr/, https://www.rust-lang.org/zh-CN/, https://www.rust-lang.org/zh-TW/, https://www.rust-lang.org/ja/, https://www.rust-lang.org/es/, https://www.rust-lang.org/it/, https://www.rust-lang.org/pt-BR/, https://www.rust-lang.org/ru/, https://www.rust-lang.org/tr/ y https://www.rust-lang.org/
Información general
Extensiones comunes	.rs
Paradigma	multiparadigma, imperativo, orientado a objetos, procedural, concurrente, funcional, compilado, propósito general
Apareció en	2010
Diseñado por	Graydon Hoare
Última versión estable	0.10​ (03 de abril de 2014 (10 años, 2 meses y 24 días))
Sistema de tipos	estático, fuerte, inferenciado, estructural
Influido por	Alef, C#, C++, Camlp4, Common Lisp, Cyclone, Erlang, Haskell, Hermes, Limbo, Napier, Napier88, Newsqueak, NIL, Ruby, Sather, Standard ML, Ocaml, Racket
Sistema operativo	Linux, Mac OS X, Windows, FreeBSD
Licencia	Licencia Apache 2.0 o Licencia MIT​

Rust es un lenguaje de programación compilado, de propósito general y multiparadigma que está siendo desarrollado por Mozilla.​ Ha sido diseñado para ser 'un lenguaje seguro, concurrente y práctico",​​ soportando programación funcional pura, por procedimientos, imperativa y orientada a objetos.

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​ y lo dio a conocer oficialmente en 2010.​ El mismo año, el trabajo pasó del compilador inicial (escrito en OCaml) al compilador auto contenido, escrito en sí mismo, en Rust.​ Conocido como rustc, se compiló a sí mismo en 2011.​ El compilador auto contenido usa LLVM como su back-end.

La primera versión alfa numerada del compilador de Rust apareció en enero de 2012.​ La versión actual es la 0.10, que fue lanzada el 3 de abril de 2014.​

Según la política de Mozilla,​ Rust es desarrollado de forma totalmente abierta y solicita la opinión y contribución de la comunidad. El diseño del lenguaje se ha ido perfeccionando a través de las experiencias en el desarrollo del motor de navegador, Servo,​ y el propio compilador de Rust. Aunque es desarrollado y patrocinado por Mozilla y Samsung, es un proyecto comunitario. Una gran parte de las contribuciones proceden de los miembros de la comunidad.​

Descripción

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. Se espera que el rendimiento de código seguro sea más lento que C++, si el rendimiento es la única consideración, pero si lo comparamos con el código C++ hecho para que tome precauciones comparables a las que toma Rust, este último puede ser incluso más rápido.​

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. No todas las estructuras de C y C++ están presentes, además, otras (como la palabra clave math para ramificación multidireccional) serán menos familiares para programadores que vienen de estos lenguajes.

El sistema está diseñado para tener un acceso seguro a la memoria, y no permite punteros nulos o punteros colgantes.​​ Los valores de los datos sólo se pueden inicializar a través de un conjunto fijo de formas, todas las cuales requieren que sus entradas hayan sido ya inicializadas.​

El sistema de tipos soporta un mecanismo similar a las clases de tipos, llamado "traits", inspirados directamente por el lenguaje Haskell. Esta es una facilidad para el polimorfismo que soporta distintos tipos de argumentos (polimorfismo ad-hoc), lograda mediante la adición de restricciones para escribir declaraciones de variables. Otras características de Haskell, como el polimorfismo de diferente tipo (Higher-kinded), no están soportadas.

Rust cuenta con inferencia de tipos, para las variables declaradas con la palabra clave let. Tales variables no requieren ser inicializadas con un valor asignado con el fin de determinar su tipo. A tiempo de compilación produce un error si cualquier rama de código falla al asignar un valor a la variable.​ Las funciones pueden recibir parámetros genéricos pero deben ser delimitados expresamente por los traits, no hay manera de dejar fuera de declaraciones de tipo sin dejar de hacer uso de los métodos y operadores de los parámetros.

La concurrencia es soportada a través de tareas simples, similares a los encontrados en Erlang y otros lenguajes basado en actores. En dichos sistemas, las tareas se comunican a través del paso de mensajes, en lugar de compartir los datos directamente. Por motivos de rendimiento, es posible enviar datos sin copiar, usar cajas únicas. Las cajas únicas son la garantía de tener un solo propietario, y puede ser liberada por la tarea de enviar para su uso por el receptor.

El sistema de objetos de Rust se basa en implementaciones, traits y tipos estructurados. Las implementaciones cumplen una función similar a la de las clases en otros lenguajes, y se definen con la palabra clave impl. Herencia y polimorfismo son proporcionados por los traits, permiten que los métodos se definan y se mezclen en las implementaciones. Los tipos estructurados se utilizan para definir los campos. Implementaciones y rasgos no pueden definir los campos propios, y sólo los traits proporcionar herencia, con el fin de evitar el problema del diamante de C++.

Ejemplos

El siguiente código es válido para Rust 0.8. En versiones posteriores puede cambiar la sintaxis o las funciones.

Programa que muestra la frase "Hola Mundo!":

fn main() {
    println("Hola Mundo!");
}

Dos versiones de la función factorial, en el estilo recursivo e iterativo:

/* The branches in this function exhibit Rust's optional implicit return
   values, which can be utilized where a more "functional" style is preferred.
   Unlike C++ and related languages, Rust's `if` construct is an expression
   rather than a statement, and thus has a return value of its own. */
fn recursive_factorial(n: int) -> int {
    if n <= 1 { 1 }
    else { n * recursive_factorial(n-1) }
}
 
fn iterative_factorial(n: int) -> int {
    // Variables are declared with `let`.
    // The `mut` keyword allows these variables to be mutated.
    let mut i = 1;
    let mut result = 1;
    while i <= n {
        result *= i;
        i += 1;
    }
    return result; // An explicit return, in contrast to the prior function.
}
 
fn main() {
    println!("Recursive result: {:i}", recursive_factorial(10));
    println!("Iterative result: {:i}", iterative_factorial(10));
}

Una simple demostración de las capacidades de concurrencia ligera de Rust:

/* This function creates ten "tasks" that all execute concurrently. Run it
   several times and observe the irregular output that results as each task
   races on stdout, due to the fact that each task may yield both between
   successive calls to `println` and within the `println` function itself. */
fn main() {
    // This string is immutable, so it can safely be accessed from multiple tasks.
    let message = "Look at me, I'm in a lightweight thread!";
    // `for` loops work with any type that implements the `Iterator` trait.
    for num in range(0, 10) {
        do spawn {
            println(message);
            // `println!` is a macro that statically verifies a format string.
            // Macros are structural (as in Scheme) rather than textual (as in C).
            println!("This message brought to you by task {:i}.", num);
        }
    }
}

Evolución del lenguaje

Además de los tipos estáticos convencionales, Rust también soportó typestates hasta su versión 0.4. El sistema typestate modela afirmaciones antes y después de las declaraciones del programa, mediante el uso de una declaración de verificación especial. Las discrepancias pueden ser descubiertas durante la compilación, en lugar de una vez que el programa se ejecuta, como podría ser el caso de las aserciones en el código C o C++. El concepto typestate no es exclusivo de Rust, ya que se introdujo por primera vez en el lenguaje de programación NIL.​Fueron retirados los typestates porque en la práctica se encontraron poco usados, sin embargo la misma funcionalidad aún se puede lograr con los patrones del mismo lenguaje.​

El estilo del sistema de objetos ha cambiado considerablemente en las versiones 0.2, 0.3 y 0.4 de Rust. La versión 0.2 introdujo clases por primera vez, con la versión 0.3 añadiendo un número de características que incluyen destructores y polimorfismo mediante el uso de interfaces. En Rust 0,4, se añadieron traits como un medio para proporcionar herencia, las interfaces se unificaron con los traits y eliminándose como una característica independiente. También se eliminaron las clases, reemplazadas por una combinación de las implementaciones y tipos estructurados.

Historial de versiones

Versión	Fecha
0.10	2014-04-03
0.9	2014-01-09
0.8	2013-09-26
0.7	2013-07-03
0.6	2013-04-02
0.5	2012-12-20
0.4	2012-10-12
0.3	2012-07-12
0.2	2012-03-28
0.1	2012-01-20

Las versiones del compilador de Rust están disponibles en https://github.com/mozilla/rust/releases.

Véase también

• Servo (motor de renderizado)

Enlaces externos

• Sitio web oficial
• Wiki de Rust
• Los archivos de desarrollo de Rust (lista de correo electrónico)
• Código fuente de Rust y sus errores