Rust (idioma)

Oxido
Logo.
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.

Descripción

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.

Historia

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 .

Caracteristicas

Sintaxis

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 .

Valor y mutabilidad

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 }


Enumeraciones y filtrado por patrón

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 patrones

Posesión y préstamo

Para 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:

  • Cualquiera de las referencias inmutables , con el operador &.
  • O una referencia mutable , con el operador & mut.

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); }

Puntos fuertes

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.

Proyectos a base de óxido

Ejemplos de código

Hola mundo  :

// This is the main function fn main() { // The statements here will be executed when the compiled binary is called // Print text to the console println!("Hello World!"); }

Matrices y rebanadas  :

use std::mem; // This function borrows a slice fn analyze_slice(slice: &[i32]) { println!("first element of the slice: {}", slice[0]); println!("the slice has {} elements", slice.len()); } fn main() { // Fixed-size array (type signature is superfluous) let xs: [i32; 5] = [1, 2, 3, 4, 5]; // All elements can be initialized to the same value let ys: [i32; 500] = [0; 500]; // Indexing starts at 0 println!("first element of the array: {}", xs[0]); println!("second element of the array: {}", xs[1]); // `len` returns the size of the array println!("array size: {}", xs.len()); // Arrays are stack allocated println!("array occupies {} bytes", mem::size_of_val(&xs)); // Arrays can be automatically borrowed as slices println!("borrow the whole array as a slice"); analyze_slice(&xs); // Slices can point to a section of an array println!("borrow a section of the array as a slice"); analyze_slice(&ys[1 .. 4]); // Out of bound indexing yields a panic println!("{}", xs[5]); }

Apéndices

Artículos relacionados

enlaces externos

Referencias

  1. “  Anunciando Rust 1.51.0 | Blog de óxido  » ,25 de marzo de 2021
  2. "  Versión 1.51.0  " ,25 de marzo de 2021
  3. "  Release 1.51.0  " ,25 de marzo de 2021(consultado el 16 de abril de 2021 )
  4. https://doc.rust-lang.org/stable/reference/influences.html
  5. “  https://github.com/rust-lang/rust/blob/master/COPYRIGHT  ”
  6. (en) "  The Rust Save  " Lambda the Ultimate,8 de julio de 2010(consultado el 30 de octubre de 2010 ) .
  7. (in) "  The Rust Programming Language  " (consultado el 21 de octubre de 2012 ) .
  8. (in) "  Doc language FAQ  " (consultado el 21 de octubre de 2012 ) .
  9. https://doc.rust-lang.org/book/ch17-01-what-is-oo.html
  10. (en) "  The Mozilla Manifesto  " (consultado el 9 de abril de 2012 ) .
  11. (en) Peter Bright, "  Samsung se asocia con Mozilla para crear un motor de navegador para máquinas multinúcleo  " ,3 de abril de 2013(consultado el 4 de abril de 2013 ) .
  12. https://www.rust-lang.org/
  13. https://doc.rust-lang.org/nomicon/what-unsafe-does.html
  14. https://www.rust-lang.org/en-US/faq.html#is-rust-garbage-collected
  15. https://benchmarksgame-team.pages.debian.net/benchmarksgame/fastest/rust.html
  16. (en) "  Preguntas frecuentes del proyecto  " ,14 de septiembre de 2010(consultado el 11 de enero de 2012 ) .
  17. (en) "  Tiempo futuro  " ,29 de abril de 2011(consultado el 6 de febrero de 2012 )  : “  En Mozilla Summit 2010, lanzamos Rust, un nuevo lenguaje de programación motivado por la seguridad y la concurrencia para el hardware paralelo, el futuro“ manycore ”que está sobre nosotros.  "
  18. (en) Graydon Hoare , "  Rust Progress  " [ archivo15 de agosto de 2014] ,2 de octubre de 2010(consultado el 30 de octubre de 2010 ) .
  19. (en) Graydon Hoare , "  [rust-dev] stage1 / rustc builds  " ,20 de abril de 2011(consultado el 20 de abril de 2011 )  :“  Después de ese último cambio que corrigió el error de contexto del alcance de registro, se ve como stage1 / rustc builds. Justo antes de la medianoche :)  ”.
  20. (in) catamorfismo, "  Mozilla y la comunidad lanzan Rust Rust 0.1 (un lenguaje de programación de sistemas fuertemente tipado con un enfoque en la seguridad de la memoria y la concurrencia)  " ,20 de enero de 2012(consultado el 6 de febrero de 2012 ) .
  21. (in) Lucian Armasu, "  Los jugadores de la gran tecnología comienzan a adoptar la arquitectura de chip RISC-V  " , en Tom's Hardware ,29 de noviembre de 2017
  22. "  Variables and Mutability - The Rust Programming Language  " , en doc.rust-lang.org (consultado el 5 de julio de 2019 )
  23. https://doc.rust-lang.org/book/second-edition/ch06-01-defining-an-enum.html#the-option-enum-and-its-advantages-over-null-values
  24. "  Presentación de Rust en Léa-Linux  " (consultado el 11 de diciembre de 2013 ) .
  25. (en) Nicholas Matsakis y Aaron Turon, "  Preámbulo  " (consultado el 12 de junio de 2019 )
  26. "  Rust 0.8 lanzado  " (consultado el 15 de octubre de 2013 ) .
  27. Vincent Hermann, "  Microsoft examina el lenguaje Rust para la programación del sistema  " (consultado el 26 de julio de 2019 )
  28. "  Shipping Rust in Firefox ★ Mozilla Hacks - the Web developer blog  " , en hacks.mozilla.org (consultado el 19 de octubre de 2016 )
  29. (in) "  Rust whitepaper NPM  " , The Rust Project Developers ,25 de febrero de 2019( leer en línea )
  30. "  Por qué Discord está cambiando de Go a Rust  " , en https://blog.discordapp.com/ (consultado el 6 de febrero de 2020 )
  31. (en-US) Boyd Johnson, "  Seguridad, rendimiento e innovación: óxido en Hyperledger Sawtooth  " ,18 de enero de 2019(consultado el 26 de agosto de 2019 )
  32. (en-US) Cade Metz , "  La historia épica del éxodo de Dropbox desde el imperio de la nube amazónica  " , WIRED ,14 de marzo de 2016( leído en línea , consultado el 19 de octubre de 2016 )