Oxido | ||
Fecha de la primera versión | 7 de julio de 2010 | |
---|---|---|
Paradigmas | Imperativo , funcional , competidor | |
Autor | Graydon hoare | |
Desarrolladores | Mozilla | |
Última versión | 1.51.0 (25 de marzo de 2021) | |
Mecanografía | Fuerte , estático | |
Influenciado por | C ++ , Erlang , Haskell , Scala , OCaml , Scheme , Swift , C # , Alef , Limbo | |
Escrito en | Oxido | |
Sistema de explotación | Multiplataforma | |
Licencia | Licencia Apache versión 2.0 y licencia MIT | |
Sitio web | www.rust-lang.org | |
Extensión de archivo | rs y rlib | |
Rust es unmulti- paradigma compilado lenguaje de programación diseñado y desarrollado por Mozilla Investigación desde 2010. Fue diseñado para ser "una, fiable concurrente , lenguaje práctico", apoyando puramente funcional , modelo de actor , de procedimiento ,los estilos de programación., Así como orientado a objetos en algunos aspectos.
En 2020, sus áreas preferidas son la programación de sistemas, las aplicaciones de línea de comandos, las aplicaciones web a través de WebAssembly , los servicios de red y los sistemas integrados.
Debido a la política de Mozilla, Rust está completamente desarrollado de manera abierta (los ingenieros de Mozilla Research publican sus ideas y decisiones tomadas en las reuniones) y solicitan comentarios y contribuciones de la comunidad. El diseño del lenguaje se mejora gradualmente a través de los comentarios del equipo que trabaja en el renderizador Servo y de forma pragmática al escribir el compilador. Aunque el proyecto está financiado por Mozilla, la mayoría de las contribuciones provienen de la comunidad.
Rust pretende ser un lenguaje potente, seguro y productivo.
En particular, el lenguaje puede proporcionar garantías de ausencia de error de segmentación o de concurrencia desde la etapa de compilación. Además, esto se hace sin recolección de basura . Su rendimiento es comparable al de C o C ++ en términos de velocidad de ejecución.
Finalmente, Rust viene con Cargo , un administrador de paquetes para administrar la compilación y las dependencias entre paquetes. El compilador proporciona mensajes de error explícitos y útiles. También hay otras herramientas de edición para IDE , así como una amplia documentación.
El lenguaje se desarrolló a partir de un proyecto personal de Graydon Hoare, quien comenzó a trabajar en él en 2006. Su empleador, Mozilla , comenzó a participar en 2009 y reveló oficialmente su trabajo por primera vez en 2010. El mismo año, el proyecto cambió del original compilador usado (escrito en OCaml ) a la auto-organizada compilador escrito en Rust. Este compilador, conocido como rustc , se compiló con éxito en 2011. El compilador autohospedado usa LLVM para su backend .
La primera versión alfa numerada del compilador de Rust apareció en enero de 2012.
La primera versión estable de Rust, 1.0, se lanzó en 2015.
En 2017, Mozilla anunció que Rust admite la compilación del conjunto de instrucciones de la arquitectura RISC-V .
La sintaxis del lenguaje es similar a C , que consiste en bloques de código delimitados por tirantes y las estructuras de control , tales como if, else, whiley for.
Sin embargo, la semántica de Rust es bastante diferente. De hecho, los bloques y las estructuras de control son expresiones, como podemos ver en el ejemplo:
let x = if n < 10 { n } else { n - 10 };En C, tal operación no es "inteligible" para el compilador; será necesario encapsular el bloque condicional en otra función o utilizar un operador ternario int x = (n < 10) ? n : n - 10;.
El uso de expresiones acerca así a Rust a lenguajes funcionales como Haskell u OCaml .
En la mayoría de los idiomas, una variable se puede editar de forma predeterminada. Rust invierte esta lógica centrándose en la coherencia: la palabra clave letdefault declara variables inmutables ( variable inmutable en inglés) que no se pueden asignar solo una vez, pero cuyo valor se puede establecer en tiempo de ejecución. Es necesario agregar la palabra clave mutpara hacer una variable "mutable" o "mutable": así, restringimos las variables que están autorizadas a cambiar. El tipo de variables se infiere siempre que sea posible.
Para valores constantes conocidos en la compilación, la palabra clave constreemplaza let. Se debe especificar su tipo y se deben inicializar a partir de una expresión constante, excluyendo los resultados de las llamadas a funciones.
fn main() { // Déclaration de variables let mut a = 5; // a est une variable modifiable let b = a * 2; // b est non modifiable et du même type que a //constantes const c:u32 = 5; // déclaration d'une constante entière non-signée const c:u8 = b - 3; // interdit car `b - 3` n'est pas une expression constante (b non défini à la compilation) const c = 5; //interdit car le type de c n'est pas précisé //altération c = 3; // illégal car c est une constante b = 3; // illégal car b est une variable immuable a = 2; // autorisé car a est déclaré comme "mut" let a = a+5; // autorisé une nouvelle variable a est créée valant 7, //l'ancienne variable a est "couverte" par la nouvelle (shadowing) //vérification des valeurs assert_eq!(a, 5);//faux assert_eq!(b, 10);//vrai }Rust permite la definición de tipos de suma (o enumeraciones) usando la palabra clave enum. Podemos usar estos tipos de suma con filtrado de patrones , por ejemplo, usando la palabra clave match.
Ejemplo:
// On crée un type « Forme » pour décrire des formes géométriques. enum Forme { Point, // une forme peut être un point, sans données attachées. Rectangle(f64, f64), // une forme peut être un rectangle, caractérisé par les longueurs de ses côtés. Cercle(f64), // une forme peut être un cercle, caractérisé par son rayon. } // Calcule l'aire d'une forme géométrique. fn aire(f: Forme) -> f64 { match f { // Filtrage par motif avec « match » Forme::Point => 0.0, Forme::Cercle(rayon) => 3.14 * rayon * rayon, Forme::Rectangle(cote_a, cote_b) => cote_a * cote_b, } }Algunas enumeraciones forman parte de la biblioteca estándar, como Option , para evitar el uso del puntero NULL .
Metaprogramación habilitada gracias al filtrado de patronesPara obtener garantías de seguridad, Rust utiliza los conceptos de propiedad (propiedad o posesión) y préstamo (endeudamiento).
Por tanto, un valor siempre tiene un solo propietario. Si el valor cambia de propiedad, el propietario anterior ya no puede usarlo.
Por ejemplo :
fn prend_possession(v: Vec<i32>) { // Cette fonction prend possession de son paramètre v et ne la rend pas. println!("{:?}", v); } fn main() { let mut a = vec![1, 2, 3]; // a est le propriétaire du vecteur. let mut b = a; // b est maintenant le propriétaire du vecteur. // pas clair, a.push(4); // erreur de compilation : a n'a plus le droit d'utiliser ce vecteur prend_possession(b); b.push(5); // erreur de compilation : b n'a plus le droit d'utiliser ce vecteur }Para utilizar un valor en varios lugares al mismo tiempo, es posible prestar este valor creando referencias .
Es posible crear:
En particular, no es posible mezclar las referencias mutables e inmutables.
Ejemplo:
fn take_reference(v: &Vec<i32>) { // Cette fonction prend une référence vers un vecteur println!("{:?}", v); } fn correct() { let a = vec![1, 2, 3]; let ref_1 = &a; let ref_2 = &a; // On crée plusieurs références immuables vers a que l'on peut passer à des fonctions. // Faire ceci ne serait pas possible si l'on travaillait avec une fonction qui prend // l'ownership de a. take_reference(ref_1); take_reference(ref_2); } fn incorrect() { let mut a = vec![1, 2, 3]; // Ce code ne compile pas. // En effet, on travaille à la fois avec une référence muable vers a (ref_1), // et à la fois avec une référence immuable vers a (ref_2). let ref_1 = &mut a[0]; let ref_2 = &a; println!("{}", *ref_1); take_reference(ref_2); }Rust se basa en conceptos conocidos y probados (de ahí el nombre Rust , "the rust " en inglés) y no integra conceptos nuevos y no probados . Estos conceptos se han tomado prestados de lenguajes de programación existentes y se han ensamblado en un solo lenguaje:
Rust se describe a menudo como uno de los posibles sucesores de C y C ++ (junto con D y, en menor medida, Go ) en parte debido a su seguridad y velocidad; este es un objetivo claramente establecido por los desarrolladores.