b'\n_START_ARTICLE_\nRust (lenguaje de programaci\xc3\xb3n)\n_START_SECTION_\nDescripci\xc3\xb3n\n_START_PARAGRAPH_\nEl objetivo de Rust es ser un buen lenguaje para la creaci\xc3\xb3n de grandes programas del lado del cliente y del servidor que se ejecuten en Internet. Esto ha llevado a un conjunto de caracter\xc3\xadsticas con un \xc3\xa9nfasis en la seguridad, el control de distribuci\xc3\xb3n de la memoria y la concurrencia. Se espera que el rendimiento de c\xc3\xb3digo seguro sea m\xc3\xa1s lento que C++, si el rendimiento es la \xc3\xbanica consideraci\xc3\xb3n, pero si lo comparamos con el c\xc3\xb3digo C++ hecho para que tome precauciones comparables a las que toma Rust, este \xc3\xbaltimo puede ser incluso m\xc3\xa1s r\xc3\xa1pido.\xe2\x80\x8b_NEWLINE_La sintaxis de Rust es similar a la de C y C++, con bloques de c\xc3\xb3digo 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\xc3\xa1n presentes, adem\xc3\xa1s, otras (como la palabra clave match para ramificaci\xc3\xb3n multidireccional) ser\xc3\xa1n menos familiares para programadores que vienen de estos lenguajes._NEWLINE_El sistema est\xc3\xa1 dise\xc3\xb1ado para tener un acceso seguro a la memoria, y no permite punteros nulos o punteros colgantes.\xe2\x80\x8b\xe2\x80\x8b Los valores de los datos s\xc3\xb3lo se pueden inicializar a trav\xc3\xa9s de un conjunto fijo de formas, las cuales requieren que sus entradas hayan sido ya inicializadas.\xe2\x80\x8b_NEWLINE_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\xc3\xb3n de restricciones para escribir declaraciones de variables. Otras caracter\xc3\xadsticas de Haskell, como el polimorfismo de diferente tipo (higher-kinded), no est\xc3\xa1n soportadas._NEWLINE_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\xc3\xb3n produce un error si cualquier rama de c\xc3\xb3digo falla al asignar un valor a la variable.\xe2\x80\x8b Las funciones pueden recibir par\xc3\xa1metros gen\xc3\xa9ricos 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\xc3\xa9todos y operadores de los par\xc3\xa1metros._NEWLINE_La concurrencia es soportada a trav\xc3\xa9s de tareas simples, similares a los encontrados en Erlang y otros lenguajes basado en actores. En dichos sistemas, las tareas se comunican a trav\xc3\xa9s del paso de mensajes, en lugar de compartir los datos directamente. Por motivos de rendimiento, es posible enviar datos sin copiar, usar cajas \xc3\xbanicas. Las cajas \xc3\xbanicas son la garant\xc3\xada de tener un solo propietario, y puede ser liberada por la tarea de enviar para su uso por el receptor._NEWLINE_El sistema de objetos de Rust se basa en implementaciones, traits y tipos estructurados. Las implementaciones cumplen una funci\xc3\xb3n 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\xc3\xa9todos 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\xc3\xb3lo los traits proporcionar herencia, con el fin de evitar el problema del diamante de C++.\n_START_SECTION_\nEjemplos\n_START_PARAGRAPH_\nEl siguiente c\xc3\xb3digo es v\xc3\xa1lido para Rust 0.8. En versiones posteriores puede cambiar la sintaxis o las funciones._NEWLINE_Programa que muestra la frase "\xc2\xa1Hola, mundo!":_NEWLINE_fn main() {    println("\xc2\xa1Hola, mundo!");}_NEWLINE_Dos versiones de la funci\xc3\xb3n factorial, en el estilo recursivo e iterativo:_NEWLINE_/* Las ramas en esta funci\xc3\xb3n exhiben los valores de retorno impl\xc3\xadcito opcional   de Rust, que pueden ser usados cuando se prefiera un estilo m\xc3\xa1s "funcional".   A diferencia de C++ y otros lenguajes similares, la estructura de control   `if` es una expressi\xc3\xb3n en vez de una declaraci\xc3\xb3n, y por tanto tiene un valor   de retorno propio. */fn recursive_factorial(n: i32) -> i32 {    if n <= 1 {        1    } else {        n * recursive_factorial(n-1)    }} fn iterative_factorial(n: i32) -> i32 {    // Las variables son declaradas con `let`.    // La palabra `mut` permite que las variables puedan ser mutadas.    let mut i = 1;    let mut result = 1;    while i <= n {        result *= i;        i += 1;    }    return result; // Un retorno expl\xc3\xadtico, en contraste con la funci\xc3\xb3n previa.} fn main() {    println!("Resultado recursivo: {:i}", recursive_factorial(10));    println!("Resultado iterativo: {:i}", iterative_factorial(10));}_NEWLINE_Una simple demostraci\xc3\xb3n de las capacidades de concurrencia ligera de Rust:_NEWLINE_/* Esta funci\xc3\xb3n crea diez "tareas" que se pueden ejecutar concurrentemente.   Ejec\xc3\xbatalo m\xc3\xbaltiples veces y observa la salida irregular que se obtiene al   estar cada tarea llamando al stdout, ya que cada tarea puede producirse entre   las sucesivas llamadas a `println` y dentro de la funci\xc3\xb3n `println` en s\xc3\xad. */fn main() {    // Esta cadena es inmutable, para que pueda ser accedida de forma segura    // por m\xc3\xbaltiples tareas.    let message = "\xc2\xa1Miradme, soy un proceso ligero!";    // Los bucles `for` funcionan con cualquier tipo que implemente el trait    // `Iterator`.    for num in range(0, 10) {        do spawn {            println(message);            // `println!` es una macro que verifica est\xc3\xa1ticamente un string de            // formato. Las macros son estructurales (como en Scheme) en lugar            // de ser textuales (como en C).            println!("Este mensaje ha sido ofrecido por la tarea {:i}.", num);        }    }}\n_START_SECTION_\nEvoluci\xc3\xb3n del lenguaje\n_START_PARAGRAPH_\nAdem\xc3\xa1s de los tipos est\xc3\xa1ticos convencionales, Rust tambi\xc3\xa9n incluy\xc3\xb3 typestates hasta su versi\xc3\xb3n 0.4. El sistema typestate modela afirmaciones antes y despu\xc3\xa9s de las declaraciones del programa, mediante el uso de una declaraci\xc3\xb3n de verificaci\xc3\xb3n especial. Las discrepancias pueden ser descubiertas durante la compilaci\xc3\xb3n, en lugar de una vez que el programa se ejecuta, como podr\xc3\xada ser el caso de las aserciones en el c\xc3\xb3digo C o C++. El concepto typestate no es exclusivo de Rust, ya que se introdujo por primera vez en el lenguaje de programaci\xc3\xb3n NIL.\xe2\x80\x8b Fueron retirados los typestates porque en la pr\xc3\xa1ctica se encontraron poco usados, sin embargo la misma funcionalidad a\xc3\xban se puede lograr con los patrones del mismo lenguaje.\xe2\x80\x8b_NEWLINE_El estilo del sistema de objetos ha cambiado considerablemente en las versiones 0.2, 0.3 y 0.4 de Rust. La versi\xc3\xb3n 0.2 introdujo clases por primera vez, con la versi\xc3\xb3n 0.3 a\xc3\xb1adiendo un n\xc3\xbamero de caracter\xc3\xadsticas que incluyen destructores y polimorfismo mediante el uso de interfaces. En Rust 0.4, se a\xc3\xb1adieron traits como un medio para proporcionar herencia, las interfaces se unificaron con los traits y elimin\xc3\xa1ndose como una caracter\xc3\xadstica independiente. Tambi\xc3\xa9n se eliminaron las clases, reemplazadas por una combinaci\xc3\xb3n de las implementaciones y tipos estructurados.'