Rust (lenguaje de programación)

De Wikipedia, la enciclopedia libre
Saltar a: navegación, búsqueda
Rust
Desarrollador(es)
Desarrolladores del proyecto Rust
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[1] (3 de abril de 2014; hace 7 días (2014-04-03))
Tipo de dato 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[2]

Rust es un lenguaje de programación compilado, de propósito general y multiparadigma que está siendo desarrollado por Mozilla.[3] Ha sido diseñado para ser 'un lenguaje seguro, concurrente y práctico",[4] [5] 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[6] y lo dio a conocer oficialmente en 2010.[7] El mismo año, el trabajo pasó del compilador inicial (escrito en OCaml) al compilador auto contenido, escrito en sí mismo, en Rust.[8] Conocido como rustc, se compiló a sí mismo en 2011.[9] 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.[10] La versión actual es la 0.10, que fue lanzada el 3 de abril de 2014.[1]

Según la política de Mozilla,[11] 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,[12] 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.[13]

Descripción[editar]

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.[14]

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.[15] [16] 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.[17]

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.[18] 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[editar]

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[editar]

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.[19] 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.[20]

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[editar]

Referencias[editar]

  1. a b Rust Release Notes
  2. «COPYRIGHT». Rust compiler source repository. Consultado el 17 de diciembre de 2012.
  3. «The Rust Language». Lambda the Ultimate (8 de julio de 2010). Consultado el 30 de octubre de 2010.
  4. «The Rust Programming Language». Consultado el 21 de octubre de 2012.
  5. «Doc language FAQ». Consultado el 21 de octubre de 2012.
  6. «Project FAQ» (14 de septiembre de 2010). Consultado el 11 de enero de 2012.
  7. «Future Tense» (29 de abril de 2011). Consultado el 6 de febrero de 2012. «At Mozilla Summit 2010, we launched Rust, a new programming language motivated by safety and concurrency for parallel hardware, the “manycore” future which is upon us.».
  8. Hoare, Graydon (2 de octubre de 2010). «Rust Progress». Consultado el 30 de octubre de 2010.
  9. Hoare, Graydon (20 de abril de 2011). «[rust-dev] stage1/rustc builds». Consultado el 20 de abril de 2011. «After that last change fixing the logging scope context bug, looks like stage1/rustc builds. Just shy of midnight :)».
  10. catamorphism (20 de enero de 2012). «Mozilla and the Rust community release Rust 0.1 (a strongly-typed systems programming language with a focus on memory safety and concurrency)». Consultado el 6 de febrero de 2012.
  11. «The Mozilla Manifesto». Consultado el 9 de abril de 2012.
  12. Peter Bright (3 de abril de 2013). «Samsung teams up with Mozilla to build browser engine for multicore machines». Consultado el 4 de abril de 2013.
  13. «Rust Contributors».
  14. Walton, Patrick (5 de diciembre de 2010). «C++ Design Goals in the Context of Rust». Consultado el 21 de enero de 2011. «… It’s impossible to be “as fast as C” in all cases while remaining safe… C++ allows all sorts of low-level tricks, mostly involving circumventing the type system, that offer practically unlimited avenues for optimization. In practice, though, C++ programmers restrict themselves to a few tools for the vast majority of the code they write, including stack-allocated variables owned by one function and passed by alias, uniquely owned objects (often used with auto_ptr or the C++0x unique_ptr), and reference counting via shared_ptr or COM. One of the goals of Rust’s type system is to support these patterns exactly as C++ does, but to enforce their safe usage. In this way, the goal is to be competitive with the vast majority of idiomatic C++ in performance, while remaining memory-safe…».
  15. Rosenblatt, Seth (3 de abril de 2013). «Samsung joins Mozilla's quest for Rust». Consultado el 5 de abril de 2013. «[Brendan Eich] noted that every year browsers fall victim to hacking in the annual Pwn2Own contest at the CanSecWest conference. "There's no free memory reads" in Rust, he said, but there are in C++. Those problems "lead to a lot of browser vulnerabilities" and would be solved by Rust, which is a self-compiling language.».
  16. Brown, Neil (17 de abril de 2013). «A taste of Rust». Consultado el 25 de abril de 2013. «… Other more complex data structures could clearly be implemented to allow greater levels of sharing, while making sure the interface is composed only of owned and managed references, and thus is safe from unplanned concurrent access and from dangling pointer errors.».
  17. «Doc language FAQ» (14 de septiembre de 2010). Consultado el 11 de enero de 2012.
  18. Walton, Patrick (1 de octubre de 2010). «Rust Features I: Type Inference». Consultado el 21 de enero de 2011.
  19. Typestate: A Programming Language Concept for Enhancing Software Reliability. IEEE Transactions on Software Engineering. 1986. ISSN 0098-5589. http://www.cs.cmu.edu/~aldrich/papers/classic/tse12-typestate.pdf. 
  20. «Typestate Is Dead, Long Live Typestate!» (26-12-2012). Consultado el 28-12-2012.

Enlaces externos[editar]