Merge remote-tracking branch 'adambard/master'

1 files changed, 324 insertions, 0 deletions

diff --git a/es-es/rust-es.html.markdown b/es-es/rust-es.html.markdown
new file mode 100644
index 00000000..b43cb815
--- /dev/null
+++ b/es-es/rust-es.html.markdown
@@ -0,0 +1,324 @@
+---
+language: rust
+contributors:
+    - ["P1start", "http://p1start.github.io/"]
+translators:
+    - ["Razican", "https://www.razican.com/"]
+filename: learnrust-es.rs
+lang: es-es
+---
+
+Rust es un lenguaje de programación desarrollado por Mozzilla Research. Rust
+combina el control del rendimiento a bajo nivel con la comodidad del alto nivel
+y garantías de seguridad.
+
+Consigue cumplir estos objetivos sin necesidad de un recolector de basura o
+runtime, haciendo posible usar las librerías de Rust como sustituto de C.
+
+La primera versión de Rust, la 0.1, fue lanzada en enero de 2012, y durante 3
+años el desarrollo fue tan rápido que hasta hace poco el uso de las versiones
+estables no era recomendable, y se aconsejaba usar las compilaciones nocturnas.
+
+El 15 de mayo de 2015 se lanzó Rust 1.0, con una garantía completa de
+retrocompatibilidad. A día de hoy los tiempos de compilación han mejorado mucho
+desde ese lanzamiento, así como otros aspectos del lenguaje y el compilador.
+Rust ha adoptado un modelo de desarrollo por series de publicaciones periódicas,
+con lanzamientos cada 6 semanas. Junto con cada lanzamiento, se lanza la beta de
+la siguiente versión.
+
+A pesar de que Rust es un lenguaje relativamente de bajo nivel, tiene conceptos
+funcionales que generalmente se encuentran en lenguajes de más alto nivel. Esto
+hace que Rust sea rápido y al mismo tiempo fácil y eficiente a la hora de
+programar.
+
+```rust
+// Esto es un comentario. Los comentarios de una sola línea se hacen así...
+/* ...y los de múltiples líneas así */
+
+//////////////////////////
+// 1. Conceptos básicos //
+//////////////////////////
+
+// Funciones
+// `i32` es el tipo para enteros de 32 bits con signo
+fn suma2(x: i32, y: i32) -> i32 {
+    // Retorno implícito (sin punto y coma)
+    x + y
+}
+
+// Función principal
+fn main() {
+    // N;umeros //
+
+    // Bindings (variables) inmutables
+    let x: i32 = 1;
+
+    // Sufijos para enteros / floats
+    let y: i32 = 13i32;
+    let f: f64 = 1.3f64;
+
+    // Inferencia de tipos
+    // La mayor parte del tiempo, el compilador de Rust puede inferir el tipo de
+    // una variable, por lo que no necesitas escribir una anotación de tipo
+    // explícita. A lo largo de este tutorial, los tipos están anotados
+    // explícitamente en varios sitios, pero solo con propósito demostrativo. La
+    // inferencia de tipos puede manejar esto por ti la mayor parte del tiempo.
+    let x_implicita = 1;
+    let f_implicita = 1.3;
+
+    // Aritmética
+    let sum = x + y + 13;
+
+    // Variable mutable
+    let mut mutable = 1;
+    mutable = 4;
+    mutable += 2;
+
+    // Strings (cadenas de caracteres) //
+
+    // Strings literales
+    let x: &str = "hola mundo!";
+
+    // Impresión por consola
+    println!("{} {}", f, x); // 1.3 hola mundo!
+
+    // Un `String` – una cadena en memoria dinámica (heap)
+    let s: String = "hola mundo".to_string();
+
+    // Una porión de cadena (slice) – una vista inmutable a otra cadena
+    // Esto es básicamente un puntero inmutable a un string string – en realidad
+    // no contiene los caracteres de la cadena, solo un puntero a algo que los
+    // tiene (en este caso, `s`)
+    let s_slice: &str = &s;
+
+    println!("{} {}", s, s_slice); // hola mundo hola mundo
+
+    // Vectores/arrays //
+
+    // A fixed-size array
+    let cuatro_enteros: [i32; 4] = [1, 2, 3, 4];
+
+    // Un array dinámico (vector)
+    let mut vector: Vec<i32> = vec![1, 2, 3, 4];
+    vector.push(5);
+
+    // Una porción (slice) – una vista inmutable a un vector o array
+    // Esto es parecido a un slice de un string, pero para vectores
+    let slice: &[i32] = &vector;
+
+    // Usa `{:?}` para imprimir algo en estilo debug
+    println!("{:?} {:?}", vector, slice); // [1, 2, 3, 4, 5] [1, 2, 3, 4, 5]
+
+    // Tuplas //
+
+    // Una tupla es un conjunto de tamaño fijo de valores. Pueden ser de diferente tipo.
+    let x: (i32, &str, f64) = (1, "hola", 3.4);
+
+    // Desestructurando `let`
+    let (a, b, c) = x;
+    println!("{} {} {}", a, b, c); // 1 hola 3.4
+
+    // Indexando
+    println!("{}", x.1); // hola
+
+    //////////////
+    // 2. Tipos //
+    //////////////
+
+    // Estructuras
+    struct Punto {
+        x: i32,
+        y: i32,
+    }
+
+    let origen: Punto = Punto { x: 0, y: 0 };
+
+    // Una estructura con campos sin nombre, una ‘estructura de tupla’
+    struct Punto2(i32, i32);
+
+    let origen2 = Punto2(0, 0);
+
+    // Enums básicos como en C
+    enum Direccion {
+        Izquierda,
+        Derecha,
+        Arriba,
+        Abajo,
+    }
+
+    let arriba = Direccion::Arriba;
+
+    // Enum con campos
+    enum OpcionalI32 {
+        UnI32(i32),
+        Nada,
+    }
+
+    let dos: OpcionalI32 = OpcionalI32::UnI32(2);
+    let nada = OpcionalI32::Nada;
+
+    // Genéricos //
+
+    struct Foo<T> { bar: T }
+
+    // Esto está definido en la librería estándar como `Option`
+    enum Opcional<T> {
+        AlgunVal(T),
+        SinVal,
+    }
+
+    // Métodos //
+
+    impl<T> Foo<T> {
+        // Los métodos reciben un parámetro explícito `self`
+        fn get_bar(self) -> T {
+            self.bar
+        }
+    }
+
+    let un_foo = Foo { bar: 1 };
+    println!("{}", un_foo.get_bar()); // 1
+
+    // Traits (conocidos como interfaces o typeclasses en otros lenguajes) //
+
+    trait Frobnicate<T> {
+        fn frobnicate(self) -> Option<T>;
+    }
+
+    impl<T> Frobnicate<T> for Foo<T> {
+        fn frobnicate(self) -> Option<T> {
+            Some(self.bar)
+        }
+    }
+
+    let otro_foo = Foo { bar: 1 };
+    println!("{:?}", otro_foo.frobnicate()); // Some(1)
+
+    /////////////////////////////////
+    // 3. Comparación con patrones //
+    /////////////////////////////////
+
+    let foo = OpcionalI32::UnI32(1);
+    match foo {
+        OpcionalI32::UnI32(n) => println!("es un i32: {}", n),
+        OpcionalI32::Nada  => println!("no es nada!"),
+    }
+
+    // comparación de patrones avanzada
+    struct FooBar { x: i32, y: OpcionalI32 }
+    let bar = FooBar { x: 15, y: OpcionalI32::UnI32(32) };
+
+    match bar {
+        FooBar { x: 0, y: OpcionalI32::UnI32(0) } =>
+            println!("Los números son cero!"),
+        FooBar { x: n, y: OpcionalI32::UnI32(m) } if n == m =>
+            println!("Los números son iguales"),
+        FooBar { x: n, y: OpcionalI32::UnI32(m) } =>
+            println!("Números diferentes: {} {}", n, m),
+        FooBar { x: _, y: OpcionalI32::Nada } =>
+            println!("El segudo número no es nada!"),
+    }
+
+    /////////////////////////
+    // 4. Flujo de control //
+    /////////////////////////
+
+    // bucles `for`
+    let array = [1, 2, 3];
+    for i in array.iter() {
+        println!("{}", i);
+    }
+
+    // Rangos
+    for i in 0u32..10 {
+        print!("{} ", i);
+    }
+    println!("");
+    // imprime `0 1 2 3 4 5 6 7 8 9 `
+
+    // `if`
+    if 1 == 1 {
+        println!("Las matemáticas funcionan!");
+    } else {
+        println!("Oh no...");
+    }
+
+    // `if` como una expresión
+    let valor = if true {
+        "bueno"
+    } else {
+        "malo"
+    };
+
+    // bucle `while`
+    while 1 == 1 {
+        println!("El universo está funcionando correctamente.");
+    }
+
+    // Bucle infinito
+    loop {
+        println!("Hola!");
+    }
+
+    ////////////////////////////////////////
+    // 5. Seguridad de memoria y punteros //
+    ////////////////////////////////////////
+
+    // Posesión de punteros – solo uno puede ‘poseer’ un puntero en cada momento
+    // Esto significa que cuando la `Box` queda fuera del ámbito, puede ser
+    // liberada automáticamente de manera segura.
+    let mut mio: Box<i32> = Box::new(3);
+    *mio = 5; // dereferenciar
+    // Aquí, `ahora_es_mio`, toma posesión de `mio`. En otras palabras, `mio` se
+    // mueve.
+    let mut ahora_es_mio = mio;
+    *ahora_es_mio += 2;
+
+    println!("{}", ahora_es_mio); // 7
+    // println!("{}", mio); // esto no compilaría, porque `now_its_mine` es el
+    // que posee el puntero
+
+    // Referencia – un puntero inmutable que referencia a otro dato
+    // Cuando se crea una referencia a un valor, decimos que el valor ha sido
+    // ‘tomado prestado’.
+    // Mientras un valor está prestado como inmutable, no puede ser modificado o
+    // movido.
+    // Una prestación dura hasta el fin del ámbito en el que se creó.
+    let mut var = 4;
+    var = 3;
+    let ref_var: &i32 = &var;
+
+    println!("{}", var); // A diferencia de `mio`, `var` se puede seguir usando
+    println!("{}", *ref_var);
+    // var = 5; // esto no compilaría, porque `var` está prestada
+    // *ref_var = 6; // esto tampoco, porque `ref_var` es una referencia
+    // inmutable
+
+    // Referencia mutable
+    // Mientras que un valor está prestado como mutable, no puede ser accedido
+    // desde ningún otro sitio.
+    let mut var2 = 4;
+    let ref_var2: &mut i32 = &mut var2;
+    *ref_var2 += 2; // '*' se usa para apuntar al var2 prestado como mutable
+
+    println!("{}", *ref_var2); // 6 , //var2 no compilaría. //ref_var2 es de
+                               // tipo &mut i32, por lo que guarda una
+                               // referencia a un i32 no el valor.
+    // var2 = 2; // esto no compilaría porque `var2` está prestado
+}
+```
+
+## Lectura adicional
+
+Rust es mucho más que esto. Esto es solo lo más básico para que puedas entender
+las cosas más importantes. Para aprender más sobre Rust, lee [The Rust
+Programming Language](http://doc.rust-lang.org/book/index.html) y echa un
+vistazo al subreddit [/r/rust](http://reddit.com/r/rust). Los compañeros en el
+canal #rust en irc.mozilla.org también son muy buenos con los recien llegados.
+También puedes acceder a [Rust users](https://users.rust-lang.org/) a pedir
+ayuda o a [Rust internals](https://internals.rust-lang.org/) para aprender más
+sobre el lenguaje y colaborar en su desarrollo.
+
+También puedes probar Rust con un compilador online en el oficial [Rust
+playpen](http://play.rust-lang.org) o en la [web principal de
+Rust](http://rust-lang.org).