├── robots.txt ├── .gitignore ├── src ├── code │ ├── rust │ │ ├── hello-world.rs │ │ ├── inmutvars.rs │ │ ├── hello-color.rs │ │ ├── mutvars.rs │ │ ├── fizzbuzz.rs │ │ ├── colored-fizzbuzz.rs │ │ └── finished-fizzbuzz.rs │ ├── c │ │ ├── inmutvars.c │ │ ├── mutvars.c │ │ └── fizzbuzz.c │ └── python │ │ └── fizzbuzz.py ├── images │ ├── rusty-lab.png │ ├── colored-rust.png │ ├── future-logo.png │ ├── colored-rust2.png │ └── rocket │ │ ├── panics.svg │ │ ├── not_desired_behavior.svg │ │ ├── does_not_compile.svg │ │ └── unsafe.svg ├── contribs.md ├── PrimeraUnidad │ ├── 03-bases.md │ ├── 00-hola-rust.md │ ├── 01-cargo.md │ ├── 04-variables-y-tipos.md │ └── 02-fizzbuzz.md ├── SUMMARY.md └── Introduccion │ ├── 01-antes-de-empezar.md │ ├── 00-intro.md │ ├── 01-windows.md │ ├── 01-macos.md │ ├── 01-linux.md │ └── 02-ide.md ├── theme ├── favicon.png └── futurelab-edition.css ├── .travis.yml ├── book.toml ├── rocket.css ├── Cargo.toml ├── LICENSE ├── rocket.js ├── CONTRIBUTING.md └── README.md /robots.txt: -------------------------------------------------------------------------------- 1 | User-agent: * 2 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | book 2 | .vscode 3 | /target 4 | **/*.rs.bk 5 | -------------------------------------------------------------------------------- /src/code/rust/hello-world.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | println!("¡Hola Mundo!"); 3 | } -------------------------------------------------------------------------------- /src/code/rust/inmutvars.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | let edad = 10; 3 | 4 | edad = 5; 5 | } -------------------------------------------------------------------------------- /theme/favicon.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/futurelabmx/rusty-lab/master/theme/favicon.png -------------------------------------------------------------------------------- /src/images/rusty-lab.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/futurelabmx/rusty-lab/master/src/images/rusty-lab.png -------------------------------------------------------------------------------- /src/images/colored-rust.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/futurelabmx/rusty-lab/master/src/images/colored-rust.png -------------------------------------------------------------------------------- /src/images/future-logo.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/futurelabmx/rusty-lab/master/src/images/future-logo.png -------------------------------------------------------------------------------- /src/images/colored-rust2.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/futurelabmx/rusty-lab/master/src/images/colored-rust2.png -------------------------------------------------------------------------------- /src/code/rust/hello-color.rs: -------------------------------------------------------------------------------- 1 | extern crate colored; 2 | 3 | use colored::*; 4 | 5 | fn main() { 6 | println!("{}", "¡Hola Rust!".red()); 7 | } -------------------------------------------------------------------------------- /src/code/rust/mutvars.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | let mut edad = 20; 3 | println!("Tienes {} años", edad); 4 | 5 | edad = 21; 6 | println!("Ahora tienes {} años", edad); 7 | } -------------------------------------------------------------------------------- /src/code/c/inmutvars.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main(int argc, char const *argv[]) 4 | { 5 | int const edad = 10; 6 | edad = 5; 7 | 8 | return 0; 9 | } 10 | -------------------------------------------------------------------------------- /src/code/rust/fizzbuzz.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | for x in 0..{ 3 | match (x % 3, x % 5) { 4 | (0, 0) => println!("FizzBuzz"), 5 | (0, _) => println!("Fizz"), 6 | (_, 0) => println!("Buzz"), 7 | (_, _) => println!("{}", x) 8 | } 9 | } 10 | } -------------------------------------------------------------------------------- /src/code/c/mutvars.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main(int argc, char const *argv[]) 4 | { 5 | int edad = 20; 6 | //C no permite la ñ 7 | printf("Tienes %d anios\n", edad); 8 | 9 | edad = 21; 10 | printf("Ahora tienes %d anios\n", edad); 11 | return 0; 12 | } 13 | -------------------------------------------------------------------------------- /theme/futurelab-edition.css: -------------------------------------------------------------------------------- 1 | /* 2 | File modified from 3 | Rust Lang book under license MIT + Apache 2 4 | all credit to respective authors. 5 | */ 6 | 7 | span.caption { 8 | font-size: .8em; 9 | font-weight: 600; 10 | } 11 | 12 | span.caption code { 13 | font-size: 0.875em; 14 | font-weight: 400; 15 | } -------------------------------------------------------------------------------- /src/contribs.md: -------------------------------------------------------------------------------- 1 | # Contributores 2 | 3 | Gracias a estas personas esta recopilación fué posible: 4 | [WIP] 5 | 6 | [PERSONAS] 7 | - Omar Jair Purata Funes [@VentGrey](https://github.com/VentGrey) 8 | - Rodolfo Ferro [@RodolfoFerro](https://github.com/RodolfoFerro) 9 | 10 | [ORGANIZACIONES] 11 | - Future Lab [@futurelabmx](https://github.com/futurelabmx) -------------------------------------------------------------------------------- /src/code/rust/colored-fizzbuzz.rs: -------------------------------------------------------------------------------- 1 | extern crate colored; 2 | 3 | use colored::*; 4 | 5 | fn main() { 6 | for x in 0..{ 7 | match (x % 3, x % 5) { 8 | (0, 0) => println!("{}","FizzBuzz".cyan()), 9 | (0, _) => println!("{}","Fizz".red()), 10 | (_, 0) => println!("{}","Buzz".yellow()), 11 | (_, _) => println!("{}", x) 12 | } 13 | } 14 | } -------------------------------------------------------------------------------- /src/code/python/fizzbuzz.py: -------------------------------------------------------------------------------- 1 | def fizzbuzz(x): 2 | """Simple FizzBuzz, courtesy of @RodolfoFerro on @GitHub""" 3 | 4 | if x % 3 == 0 and x % 5 == 0: 5 | return "FizzBuzz" 6 | elif x % 3 == 0: 7 | return "Fizz" 8 | elif x % 5 == 0: 9 | return "Buzz" 10 | else: 11 | return str(x) 12 | 13 | if __name__ == '__main__': 14 | sequence = '\n'.join(fizzbuzz(x) for x in range(1, 100)) 15 | print(sequence) 16 | -------------------------------------------------------------------------------- /src/code/c/fizzbuzz.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main(int argc, char *argv[]) 4 | { 5 | for (int i = 1; i <= 100; i++) { 6 | if (i % 3 == 0) 7 | printf("Fizz"); 8 | if (i % 5 == 0) 9 | printf("Buzz"); 10 | if (i % 3 != 0 && i % 5 != 0) 11 | printf("%d", i); 12 | 13 | printf("\n"); 14 | } 15 | return 0; 16 | } 17 | -------------------------------------------------------------------------------- /src/PrimeraUnidad/03-bases.md: -------------------------------------------------------------------------------- 1 | # Preludio 2 | 3 | En el capítulo anterior te enseñamos a crear un pequeño programa FizzBuzz, en 4 | este pequeño capítulo comenzaremos de lleno a mostrarte las bases del lenguaje 5 | de programación Rust, también dejaremos pequeños ejercicios para que practiques 6 | los temas que tratemos en cada capítulo. También incluiremos pequeños proyectos 7 | en los que te guiaremos paso a paso para que desarrolles tu habilidad para 8 | crear las herramientas necesarias en tu entorno. 9 | 10 | ¡Vamos a por ello! 11 | -------------------------------------------------------------------------------- /.travis.yml: -------------------------------------------------------------------------------- 1 | language: rust 2 | sudo: false 3 | 4 | cache: 5 | - cargo 6 | 7 | rust: 8 | - stable 9 | 10 | before_script: 11 | - (test -x $HOME/.cargo/bin/cargo-install-update || cargo install cargo-update) 12 | - (test -x $HOME/.cargo/bin/mdbook || cargo install --vers "^0.1" mdbook) 13 | - cargo install-update -a 14 | 15 | script: 16 | - mdbook build && mdbook test 17 | 18 | deploy: 19 | provider: pages 20 | skip-cleanup: true 21 | github-token: $GITHUB_TOKEN 22 | local-dir: book/ 23 | keep-history: false 24 | on: 25 | branch: master -------------------------------------------------------------------------------- /book.toml: -------------------------------------------------------------------------------- 1 | [book] 2 | authors = ["VentGrey, FutureLab"] 3 | multilingual = true 4 | src = "src" 5 | title = "Rusty Lab" 6 | 7 | [output.html] 8 | mathjax-support = true 9 | additional-css = ["rocket.css","theme/futurelab-edition.css"] 10 | additional-js = ["rocket.js"] 11 | 12 | [output.html.playpen] 13 | editable = true 14 | 15 | [output.html.search] 16 | enable = true 17 | limit-results = 30 18 | teaser-word-count = 30 19 | use-boolean-and = true 20 | expand = true 21 | 22 | [output.html.links] 23 | title = "GitHub Repo" 24 | icon = "fa-github" 25 | href = "https://github.com/futurelabmx/rusty-lab" 26 | 27 | [build] 28 | create-missing = true -------------------------------------------------------------------------------- /src/code/rust/finished-fizzbuzz.rs: -------------------------------------------------------------------------------- 1 | extern crate colored; 2 | 3 | use colored::*; 4 | use std::io; 5 | 6 | fn main() { 7 | let mut entrada = String::new(); 8 | println!("Ingrese el número de iteraciones deseadas:"); 9 | io::stdin().read_line(&mut entrada).unwrap(); 10 | 11 | let iter: i32 = entrada.trim().parse().unwrap(); 12 | 13 | for x in 0..=iter { 14 | match (x % 3, x % 5) { 15 | (0, 0) => println!("{}", "FizzBuzz".cyan()), 16 | (0, _) => println!("{}", "Fizz".red()), 17 | (_, 0) => println!("{}", "Buzz".yellow()), 18 | (_, _) => println!("{}", x), 19 | } 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /rocket.css: -------------------------------------------------------------------------------- 1 | body.light .does_not_compile, 2 | body.light .panics, 3 | body.light .not_desired_behavior, 4 | body.rust .does_not_compile, 5 | body.rust .panics, 6 | body.rust .not_desired_behavior { 7 | background: #fff1f1; 8 | } 9 | 10 | body.coal .does_not_compile, 11 | body.coal .panics, 12 | body.coal .not_desired_behavior, 13 | body.navy .does_not_compile, 14 | body.navy .panics, 15 | body.navy .not_desired_behavior, 16 | body.ayu .does_not_compile, 17 | body.ayu .panics, 18 | body.ayu .not_desired_behavior { 19 | background: #501f21; 20 | } 21 | 22 | .rocket { 23 | position: absolute; 24 | z-index: 99; 25 | right: 5px; 26 | top: 30px; 27 | width: 10%; 28 | height: auto; 29 | } 30 | 31 | .rocket-explain { 32 | width: 100px; 33 | } -------------------------------------------------------------------------------- /src/SUMMARY.md: -------------------------------------------------------------------------------- 1 | # Summary 2 | 3 | - [Introducción](Introduccion/00-intro.md) 4 | - [Antes de empezar](Introduccion/01-antes-de-empezar.md) 5 | - [Instalación en Microsoft Windows](Introduccion/01-windows.md) 6 | - [Instalación en Mac OS](Introduccion/01-macos.md) 7 | - [Instalación en Gnu/Linux](Introduccion/01-linux.md) 8 | - [¿IDE o Editor de Texto?](Introduccion/02-ide.md) 9 | - [¡Hola Rust!](PrimeraUnidad/00-hola-rust.md) 10 | - [¿Cargo?](PrimeraUnidad/01-cargo.md) 11 | - [FizzRust](PrimeraUnidad/02-fizzbuzz.md) 12 | - [Aprendiendo las bases](PrimeraUnidad/03-bases.md) 13 | - [Variables y tipos](PrimeraUnidad/04-variables-y-tipos.md) 14 | -------------------------------------------------------------------------------- 15 | [Contribuidores](contribs.md) -------------------------------------------------------------------------------- /Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "rusty-lab" 3 | version = "0.1.0" 4 | authors = ["Future Lab "] 5 | edition = "2018" 6 | 7 | # Binary Locations (RLS) 8 | 9 | [[bin]] 10 | name = "hello_world" 11 | path = "code/rust/hello-world.rs" 12 | 13 | [[bin]] 14 | name = "hello_colored" 15 | path = "code/rust/hello-color.rs" 16 | 17 | [[bin]] 18 | name = "fizzbuzz" 19 | path = "code/rust/fizzbuzz.rs" 20 | 21 | [[bin]] 22 | name = "colored_fizzbuzz" 23 | path = "code/rust/colored-fizzbuzz.rs" 24 | 25 | [[bin]] 26 | name = "finished_fizzbuzz" 27 | path = "code/rust/finished-fizzbuzz.rs" 28 | 29 | [[bin]] 30 | name = "inmutvars" 31 | path = "code/rust/inmutvars.rs" 32 | 33 | [[bin]] 34 | name = "mutvars" 35 | path = "code/rust/mutvars.rs" 36 | 37 | [dependencies] 38 | colored = "1.7.0" -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2018 Future Lab 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /src/Introduccion/01-antes-de-empezar.md: -------------------------------------------------------------------------------- 1 | # ¡Prepara tu entorno! 2 | 3 | ¡Bienvenido! Si es tu primera vez utilizando el lenguaje de programación Rust 4 | este capítulo es para ti, antes de comenzar a escribir centenares de líneas de 5 | código necesitamos preparar nuestro entorno de desarrollo. 6 | 7 | > Este libro asume que posees conocimientos básicos de programación, si eres o 8 | > te consideras un novato en esta área te recomendamos comenzar por un lenguaje 9 | > más sencillo como C o Python. 10 | 11 | Antes que nada tenemos que instalar Rust en nuestra computadora, dependiendo de 12 | nuestro sistema operativo nuestra instalación será diferente y necesitará más o 13 | menos pasos para configurarse correctamente. 14 | 15 | Por ahora necesitaremos: 16 | 17 | * Una computadora 18 | * Acceso a Internet 19 | 20 | En los capítulos **2.1**, **2.2** y **2.3** cubriremos la instalación en 21 | diferentes sistemas operativos comunes, si ya posees Rust instalado o si 22 | consideras que puedes guiarte durante el proceso de instalación te 23 | recomendamos mirar el capítulo **2.4** para que elijas tu editor preferido 24 | o puedes saltar hacia el capítulo **3** para comenzar a trabajar en Rust. 25 | 26 | > Solo cubriremos los sistemas operativos más conocidos o más populares, siendo 27 | > estos "Windows", "Mac OS" & "Gnu/Linux". No cubriremos la instalación en otro 28 | > sistema unix-like, aun así, si deseas contribuir con la instalación en otro 29 | > sistema operativo eres bienvenido :) -------------------------------------------------------------------------------- /rocket.js: -------------------------------------------------------------------------------- 1 | var rocketTypes = [ 2 | { 3 | attr: 'does_not_compile', 4 | title: '¡Este código no compila!' 5 | }, 6 | { 7 | attr: 'panics', 8 | title: '¡Este código entra en pánico!' 9 | }, 10 | { 11 | attr: 'unsafe', 12 | title: 'El bloque contiene código inseguro.' 13 | }, 14 | { 15 | attr: 'not_desired_behavior', 16 | title: 'This code does not produce the desired behavior.' 17 | } 18 | ] 19 | 20 | document.addEventListener('DOMContentLoaded', () => { 21 | for (var rocketType of rocketTypes) { 22 | attachRockets(rocketType) 23 | } 24 | }) 25 | 26 | function attachRockets(type) { 27 | var elements = document.getElementsByClassName(type.attr) 28 | 29 | for (var codeBlock of elements) { 30 | var lines = codeBlock.textContent.split(/\r|\r\n|\n/).length - 1; 31 | 32 | if (lines >= 4) { 33 | attachRocket(codeBlock, type) 34 | } 35 | } 36 | } 37 | 38 | function attachRocket(element, type) { 39 | var a = document.createElement('a') 40 | a.setAttribute('href', 'ch00-00-introduction.html#ferris') 41 | a.setAttribute('target', '_blank') 42 | 43 | var img = document.createElement('img') 44 | img.setAttribute('src', 'images/rocket/' + type.attr + '.svg') 45 | img.setAttribute('title', type.title) 46 | img.className = 'rocket' 47 | 48 | a.appendChild(img) 49 | 50 | element.parentElement.insertBefore(a, element) 51 | } -------------------------------------------------------------------------------- /CONTRIBUTING.md: -------------------------------------------------------------------------------- 1 | # ¿Deseas contribuir? 2 | 3 | ¡Bienvenido! En este documento te mostraremos las guías de 4 | contribución de nuestro repositorio para asegurar la 5 | calidad del código y el mantenimiento del proyecto :smile: 6 | 7 | Antes de empezar aquí te recomendamos leer antes el manual de usuario de 8 | [mdbook](https://rust-lang-nursery.github.io/mdBook/) ya que este es el 9 | motor que usaremos en nuestro "libro". 10 | 11 | ## Archivos .md 12 | Cualquiera puede escribir una página o un capítulo en este repositorio, solo 13 | te pedimos que tomes en cuenta los siguientes lineamientos: 14 | 15 | * Procura que tus archivos no pasen de la columna 80. 16 | (sabemos que no siempre es posible debido a los enlaces u otros medios). 17 | * Se claro y simple al explicar un bloque de código si es que incluyes uno. 18 | * Añade las referencias si es que utilizas alguna, incluso si la licencia del 19 | artículo, libro, revista o página web que consultaste permite la reproducción 20 | sin mención al autor (Hacer esto en el formato de tu preferencia). 21 | * Mantén una buena ortografía en tus archivos, sabemos que todos cometemos 22 | errores, procura mitigar todos los que puedas y no te preocupes si se te escapan 23 | uno o dos, la comunidad te ayudará a encontrarlos y mejorar :wink: 24 | * Evita el lenguaje altisonante, comúnmente conocido como *"Groserías"*. 25 | * Si vas a corregir un archivo `.md` de otro usuario procura describir que 26 | cambios hiciste y las razones de éstos siempre manteniendo el respeto. 27 | 28 | 29 | ## Archivos .rs 30 | 31 | Los archivos de Rust que incluyas en el repositorio deberán respetar el estilo 32 | de código propuesto en la guía oficial de Rust. 33 | 34 | * Sangría de 4 espacios, **no tabulaciones**, espacios. 35 | * Comentado en caso de necesitar correcciones o interacción con el usuario. -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 |

Rusty-Lab

2 | 3 |

4 | Rusty-lab 5 |

6 | 7 | [![](https://img.shields.io/github/downloads/futurelabmx/rusty-lab/total.svg)](https://github.com/futurelabmx/rusty-lab) 8 | 9 | > Logo made here: logomakr.com/8gIeL8 10 | 11 | # ¡Aprende Rust con Future Lab! 12 | 13 | [![](https://img.shields.io/github/issues/futurelabmx/rusty-lab.svg)](https://github.com/futurelabmx/rusty-lab/issues) [![](https://img.shields.io/github/stars/futurelabmx/rusty-lab.svg)](https://github.com/futurelabmx/rusty-lab/stargazers) 14 | ## Despliegue 15 | 16 | | Plataforma | Lenguajes | Libro (PDF/EPUB) | Status | 17 | | ---------- | ------------- | ---------------- | ----------------------------------------------------------------------------------------------------------------------------- | 18 | | Travis.CI | Rust `1.31.x` | **EN ESPERA** | [![Build Status](https://travis-ci.org/futurelabmx/rusty-lab.svg?branch=master)](https://travis-ci.org/futurelabmx/rusty-lab) | 19 | 20 | El libro se encuentra en construcción, nuevos capítulos serán añadidos con el 21 | tiempo, si deseas contribuir puedes leer el archivo 22 | [CONTRIBUTING.md](CONTRIBUTING.md), las prioridades para este repositorio son: 23 | 24 | - [ ] Crear una página principal fuera del libro. 25 | - [ ] Crear un tema CSS personalizado para el libro. 26 | - [x] Agregar un Favicon para verse cool :sunglasses: 27 | - [x] Incluir archivos `.rs` para modificaciones futuras. 28 | - [ ] Escribir acerca de las `crates`. 29 | - [ ] Relacionar Rust con otros lenguajes. 30 | - [ ] Automatizar la generación diaria de archivos `EPUB`. 31 | - [ ] Crear un CSS personalizado para indicar errores similar al utilizado en 32 | el libro oficial, preferiblemente con los siguientes elementos: 33 | * Indicador de código que no compila 34 | * Indicador de códifo que entra en pánico 35 | * Indicador de código sin salida 36 | * Indicador de código inseguro 37 | 38 | En el libro deseamos presentar Rust a los programadores de diversos lenguajes, 39 | debido a esto, si exponemos un problema y lo presentamos en X o Y lenguaje 40 | te invitamos a presentar la solución en el lenguaje de tu preferencia, esto 41 | con el fin de mostrar la capacidad de Rust para trabajar como y en conjunto con 42 | otros lenguajes. 43 | 44 | ## Copyright externo 45 | 46 | Este repositorio utiliza recursos encontrados en 47 | https://github.com/rust-lang/book/ el cual posee una doble licencia 48 | MIT + Apache, todos los archivos expresador o utilizados aquí recibiran el 49 | reacondicionamiento propio para su uso e inclusión. 50 | 51 | Archivos bajo estos términos: 52 | 53 | * rocket.css 54 | * futurelab-edition.css 55 | * rocket.js -------------------------------------------------------------------------------- /src/Introduccion/00-intro.md: -------------------------------------------------------------------------------- 1 | # Prólogo 2 | 3 | Lo hemos escuchado muchas veces, más cuando nos vemos envueltos en situaciones 4 | críticas al momento de producir software, necesitamos desarrollar herramientas 5 | que requieren ser rápidas, precisas y de bajo consumo de recursos. 6 | 7 | Existe una cantidad vasta de lenguajes de programación, bibliotecas y frameworks 8 | que nos pueden ayudar a realizar nuestro trabajo, aun así no todos son lo que 9 | definiríamos como *"La herramienta correcta"* para el trabajo que necesitamos 10 | entregar en dos semanas a un cliente altamente exigente. 11 | 12 | Cuando nos adentramos al lenguaje de programación *Rust* no tenemos línea alguna 13 | que nos especifique los límites de el lenguaje, pues el objetivo principal de 14 | Rust es el otorgar control, la adquisición de poder e independencia por parte 15 | del programador. 16 | 17 | Rust cumple conos paradigmas y su naturaleza extensible permite que los 18 | programadores desarrollen sus ideas sin límites que pueden llegas a ser molestos 19 | después de lidiar una o dos veces con ellos, pensemos en lenguajes de 20 | programación como C o C++, estos dos lenguajes son las bases de mucha de la 21 | tecnología usada actualmente, la mayoría de los dispositivos que usamos 22 | cuentan con un sistema operativo escrito mayormente en C o C++, sin embargo 23 | estos lenguajes de programación no son perfectos, el control que le es ofrecido 24 | al usuario no está regulado por criterios de ningún tipo lejos de la sintaxis 25 | y algunas protecciones básicas en la memoria (sin mencionar la protección que 26 | otorga el sistema operativo en muchos casos). 27 | 28 | Aun así los lenguajes de programación como C o C++ no poseen una regulación muy 29 | profunda, lo cual puede llevar a cometer los errores más comunes que se conocen 30 | en estos lenguajes como: 31 | 32 | * Memory leaks 33 | * Data races 34 | * Stack & Buffer overflow 35 | * Null pointers 36 | * Segfaults 37 | * etc. 38 | 39 | Pensemos en el enfoque principal de Rust, ser un lenguaje de programación de 40 | sistemas, un nivel en el que se trabaja con un manejo avanzado de la memoria del 41 | sistema, representación extensiva de datos, concurrencia, trabajar con 42 | diferentes hilos de ejecución y más. Esto puede ser visto como algo duro o 43 | difícil pues es muy fácil cometer errores que pueden congelar, dañar parcial o 44 | totalmente un sistema funcional e incluso los programadores de 45 | sistemas con más experiencia no están libres de cometer errores menores que 46 | dejan sus programas expuestos a vulnerabilidades, cierres inesperados o 47 | corrupción de datos parcial o total. 48 | 49 | 50 | Rust no se limita solo a programación de sistemas, al ser extremadamente modular 51 | permite aplicaciones CLI, GUI's con [gtk-rs](https://gtk-rs.org/) o incluso 52 | puedes desplegar tus propias web-apps utilizando 53 | [rocket](https://rocket.rs/), un poderoso framework hecho completamente en Rust. 54 | 55 | Incluso si eres un programador que trabaja a bajo nivel puedes reescribir tus 56 | proyectos en Rust para mejorar su tiempo de ejecución, seguridad, 57 | concurrencia o legibilidad sin miedo a introducir nuevos errores 58 | o vulnerabilidades. 59 | 60 | En este libro comunitario aprenderás a manejar las bases del lenguaje de 61 | programación Rust, podrás aplicar tus conocimientos para mejorar o 62 | realizar nuevos proyectos, no esperes más, toma tu computadora, una 63 | libreta y empieza a aprender con nosotros. 64 | 65 | -- Future Lab 66 | ![Future Lab](../images/future-logo.png) -------------------------------------------------------------------------------- /src/PrimeraUnidad/00-hola-rust.md: -------------------------------------------------------------------------------- 1 | # ¡Hola Rust! 2 | 3 | Tenemos todo lo necesario, ahora vamos a escribir nuestro primer 4 | programa en Rust. 5 | 6 | Existe una tradición entre los programadores, siempre que se aprende un 7 | nuevo lenguaje de programación, el primer programa que se escribe es un 8 | *"Hola mundo"*. 9 | 10 | No cubriremos a fondo el uso de la línea de comandos por lo tanto 11 | asumiremos que ya posees las habilidades para crear, renombrar o 12 | borrar directorios/archivos. 13 | 14 | Vamos a crear nuestro primer archivo fuente de Rust y lo llamaremos 15 | `main.rs`, es importante saber que TODOS los archivos de Rust terminan 16 | con la extensión `.rs`, las reglas para el nombre de los archivos son las 17 | mismas que aplican para otros lenguajes de programación. 18 | 19 | Ahora con tu editor de texto favorito abre el archivo `main.rs` y coloca 20 | lo siguiente: 21 | 22 | {{#playpen ../code/rust/hello-world.rs}} 23 | 24 | Es un pequeño programa que imprime las palabras `¡Hola Mundo!` en la 25 | consola. 26 | 27 | Puedes ejecutar el código desde este mismo libro aun así, te 28 | recomendamos que practiques en tu terminal. 29 | 30 | Guarda tu archivo `main.rs` y en tu terminal procede a llamar al 31 | compilador de Rust llamado `rustc`. Mas adelante explicaremos como 32 | funciona a fondo `rustc`, por ahora procederemos a compilar nuestro 33 | programa de la siguiente manera: 34 | 35 | ```ignore 36 | $ rustc main.rs 37 | $ ./main 38 | ¡Hola Mundo! 39 | ``` 40 | > Los comandos están expresados en un entorno UNIX-Like. 41 | 42 | Vamos a descomponer nuestro programa en partes para entender un poco mejor 43 | lo que está pasando. 44 | 45 | Veamos la primera parte del programa: 46 | 47 | ```rust,ignore 48 | fn main() { 49 | ``` 50 | 51 | Lo primero que vemos es el abstracto `fn` el cual se utiliza para declarar 52 | funciones en Rust. Mas delante podemos ver `main()`, esto es el identificador de 53 | la función, a la derecha podemos ver un par de paréntesis, al igual que en otros 54 | lenguajes los paréntesis al lado del identificador de la función sirven para 55 | indicar los parámetros que esta va a recibir al momento de ser llamada. 56 | 57 | El último elemento que podemos ver es una *"llave abierta"*, ésta indica el 58 | inicio de un bloque de código `{`. 59 | 60 | La siguiente línea que podemos ver es esta: 61 | 62 | ```rust,ignore 63 | println!("¡Hola Mundo!"); 64 | ``` 65 | 66 | A diferencia de otros lenguajes, Rust no utiliza funciones para la salida de 67 | consola, en este caso `println!` es un macro que es un elemento de 68 | *metaprogramación* que exploraremos más tarde, por ahora recuerda que al llamar 69 | un macro siempre deberás de colocar un `!` después del identificador. 70 | 71 | Dentro del macro `println!` encontramos el elemento `"¡Hola Mundo!"`. Esto es 72 | una cadena de carácteres que funciona como argumento del macro. 73 | 74 | En la última línea podemos ver una llave cerrada, la cual indica el final de un 75 | bloque de código. 76 | 77 | Rust es un lenguaje de programación compilado, si tienes experiencia con 78 | lenguajes como C o C++ sabrás que después de escribir el código fuente 79 | es necesario pasar el archivo resultante por un compilador, en el caso 80 | de C o C++ se utiliza `gcc` o `clang`, en Rust usaremos `rustc`. 81 | 82 | Si vienes de lenguajes dinámicos, mejor conocidos como interpretados como 83 | Python o Ruby probablemente te sea un poco difícil acostumbrarte a 84 | compilar y ejecutar. A diferencia de otros lenguajes de programación 85 | compilados Rust puede considerarse como *adelantado* en esa cuestión ya 86 | que puedes compilar un programa y enviar el binario generado a otra 87 | persona para que lo ejecute, incluso sin tener Rust instalado. 88 | 89 | Cuando proporcionas a otra persona tu script con terminación en `.rb` o 90 | `.py` todo lo que necesitan es tener instalado en su computadora el 91 | lenguaje de programación correspondiente. 92 | 93 | Compilar nuestros programas con `rustc` está bien si estamos 94 | desarrollando software simple, pero si deseamos crear proyectos más 95 | ambiciosos y con un poco más de complejidad, en el capítulo **4** 96 | discutiremos acerca de `cargo`, el gestor de paquetes de Rust. -------------------------------------------------------------------------------- /src/Introduccion/01-windows.md: -------------------------------------------------------------------------------- 1 | # Instalación en Microsoft Windows 2 | 3 | En este apartado instalaremos las herramientas necesarias para programar 4 | en el lenguaje de programación Rust dentro de un sistema operativo Microsoft 5 | Windows. 6 | 7 | ## Instalar Rustup 8 | 9 | Lo primero que necesitamos es `rustup`, el cual es un instalador del 10 | lenguaje y sus respectivas herramientas. 11 | 12 | > [Sitio oficial de Rustup](https://rustup.rs/) 13 | 14 | Si estás en una instalación de 64 bits te recomendamos instalar 15 | utilizando el siguiente [enlace](https://win.rustup.rs/x86_64). 16 | 17 | En caso contrario puedes usar el [instalador](https://win.rustup.rs/i686) 18 | de 32 bits. 19 | 20 | No te preocupes si resulta confuso al inicio, el instalador de Rust 21 | te guiará paso a paso en el proceso. 22 | 23 | Si te consideras un novato en el lenguaje te recomendamos mantener los 24 | ajustes de instalación por defecto. 25 | 26 | Si deseas empaparte con un poco más de información continúa leyendo o 27 | si consideras que la instalación es suficiente puedes pasar al siguiente 28 | capítulo. 29 | 30 | ## Los canales de actualización 31 | 32 | El desarrollo de Rust es muy activo, por lo que opera en tres canales de 33 | distribución: 34 | 35 | * Stable 36 | * Beta 37 | * Nightly 38 | 39 | Si eres un usuario novel te recomendamos mantenerte en el canal `Stable`. 40 | 41 | > Los canales `Beta` o `Nightly` son para aquellos valientes que desean 42 | > probar características más recientes del lenguaje aunque a veces son 43 | > necesarios para algunas herramientas. 44 | 45 | Vamos a explicar/traducir el proceso de liberación de Rust como viene 46 | explicado en el [libro](https://doc.rust-lang.org/book/appendix-07-nightly-rust.html?highlight=channel#choo-choo-release-channels-and-riding-the-trains): 47 | 48 | > Necesitarás conocimientos básicos de Git para entender algunas cosas. 49 | 50 | Cada vez que se añade una característica a Rust, se crea un *commit* en 51 | la rama `master` del repositorio. Esto pasa con frecuencia ya que la 52 | comunidad de Rust es muy activa, por lo tanto cada noche una nueva 53 | versión del canal `Nightly` se produce, es decir, todos los días se 54 | libera una nueva versión con el *hash* del último commit aceptado dentro 55 | de `Nightly`, la rama `master` durante el transcurso del día podría 56 | verse algo así: 57 | 58 | `nightly: * - - * - - *` 59 | 60 | > Cada `*` representa un *commit*. 61 | 62 | Como los ciclos de liberación son fijos cada seis semanas el equipo de 63 | desarrollo de Rust se prepara para liberar una nueva versión, antes que 64 | nada primero deben migrar los cambios, por lo que la rama `beta` sale 65 | de la rama `master` y con eso tendremos nuestra liberación `beta`. 66 | 67 | ```ignore 68 | nightly: * - - * - - * 69 | | 70 | beta: * 71 | ``` 72 | 73 | La mayoría de los usuarios de Rust no utiliza este canal de forma 74 | activa, en su lugar utilizan *Sistemas de Integración Continua* para 75 | detectar cualquier posible regresión o error. Mientras esto ocurre, la 76 | rama `master` continúa actualizandose. 77 | 78 | ```ignore 79 | nightly: * - - * - - * - - * - - * 80 | | 81 | beta: * 82 | ``` 83 | 84 | En caso de que una regresión se encuentre las cosas apuntan a nuestro 85 | favor, pues la edición `beta` primero fue probada antes de enviar los 86 | cambios a la versión estable, lo que se hace en estos casos es aplicar 87 | un parche en la rama `master` y después migrarlo a la rama `beta`. 88 | 89 | ```ignore 90 | nightly: * - - * - - * - - * - - * - - * 91 | | 92 | beta: * - - - - - - - - * 93 | ``` 94 | 95 | Seis semanas después de la liberación de la rama `beta` es tiempo de 96 | enviar una nueva versión estable, por lo que una rama llamada `stable` 97 | saldrá de la rama `beta`: 98 | 99 | ```ignore 100 | nightly: * - - * - - * - - * - - * - - * - * - * 101 | | 102 | beta: * - - - - - - - - * 103 | | 104 | stable: * 105 | ``` 106 | 107 | Bien, una nueva versión de Rust está lista para usarse, pero tenemos 108 | que considear algo y es que han pasado 6 semanas, por lo que una nueva 109 | versión `beta` viene en camino, por lo tanto cada que se libera una 110 | versión estable, se crea una nueva versión beta. 111 | 112 | ## Herramientas de desarrollo para Rust 113 | 114 | * Racer (Nightly): `cargo install racer`. 115 | * rustfmt (Stable - Nightly): `rustup component add rustfmt`. 116 | * rust-doc (Stable - Nightly): `rustup component add rust-doc`. 117 | 118 | Si deseamos una integración propia con un IDE debemos de instalar 119 | [rls](https://github.com/rust-lang/rls) el cual es un servidor de 120 | lenguaje que nos ayudará con el resaltado de errores en tiempo real 121 | y nos proporcionará de otras funciones útiles. 122 | 123 | * RLS (Stable - Nightly): 124 | `rustup component add rls-preview rust-analysis rust-src` 125 | 126 | ¡Listo! Con esto tenemos nuestro entorno base para escribir programas en Rust. 127 | Ahora tenemos que elegir un IDE para empezar a desarrollar. 128 | 129 | Ve al capítulo **2.4** para ver nuestras recomendaciones o al capítulo **3** si 130 | deseas comenzar a escribir tus programas en Rust. -------------------------------------------------------------------------------- /src/Introduccion/01-macos.md: -------------------------------------------------------------------------------- 1 | # Instalación en Mac OS 2 | 3 | La instalación en Mac OS es similar a la instalación en los sistemas operativos 4 | tipo unix. 5 | 6 | Antes de empezar, si posees el gestor de paquetes 7 | [homebrew](https://brew.sh/index_es) te recomendamos hacer la instalación por 8 | este medio ya que es más sencillo y el resultado es el mismo: 9 | 10 | * Instalación de Rustup 11 | `$ brew install rustup` 12 | 13 | * Iniciar la instalación de Rust 14 | `$ rustup-init` 15 | 16 | * Verificar nuestra instalación de Rust con: 17 | `$ rustc --version` 18 | 19 | 20 | Puedes instalar desde la terminal provista por tu sistema operativo ejecutando 21 | el siguiente comando: 22 | 23 | `curl https://sh.rustup.rs -sSf | sh` 24 | 25 | Con esto descargaremos la versión más reciente de Rustup y procederemos con la 26 | instalación del lenguaje. 27 | 28 | No te preocupes si resulta confuso al inicio, el instalador de Rust 29 | te guiará paso a paso en el proceso. 30 | 31 | Si te consideras un novato en el lenguaje te recomendamos mantener los 32 | ajustes de instalación por defecto. 33 | 34 | Para actualizar tus herramientas de Rust necesitaras ejecutar el comando 35 | `$ rustup update`. 36 | 37 | ## Configurar la variable de entorno 38 | 39 | Al proceder con la instalación de Rust, todas las herramientas se 40 | almacenarán en el directorio `~/.cargo/bin`, ahí encontrarás todo el 41 | software que has descargado como `rustc`, `cargo` y `rustup`. 42 | 43 | Es opcional (y conveniente) incluir este directorio en una variable de 44 | entorno, durante la instalación `rustup` intentará configurar dicha 45 | variable definida como `PATH`. Como todas las líneas de comandos son 46 | diferentes las modificaciones hacia `PATH` podrían no surtir efecto 47 | hasta que se reinicie la consola, al salir de la sesión o puede no 48 | funcionar del todo, por lo que como usuario te tocará corregir este 49 | error por tus medios. 50 | 51 | Si deseas empaparte con un poco más de información continúa leyendo o 52 | si consideras que la instalación es suficiente puedes pasar al siguiente 53 | capítulo. 54 | 55 | ## Los canales de actualización 56 | 57 | El desarrollo de Rust es muy activo, por lo que opera en tres canales de 58 | distribución: 59 | 60 | * Stable 61 | * Beta 62 | * Nightly 63 | 64 | Si eres un usuario novel te recomendamos mantenerte en el canal `Stable`. 65 | 66 | > Los canales `Beta` o `Nightly` son para aquellos valientes que desean 67 | > probar características más recientes del lenguaje aunque a veces son 68 | > necesarios para algunas herramientas. 69 | 70 | Vamos a explicar/traducir el proceso de liberación de Rust como viene 71 | explicado en el [libro](https://doc.rust-lang.org/book/appendix-07-nightly-rust.html?highlight=channel#choo-choo-release-channels-and-riding-the-trains): 72 | 73 | > Necesitarás conocimientos básicos de Git para entender algunas cosas. 74 | 75 | Cada vez que se añade una característica a Rust, se crea un *commit* en 76 | la rama `master` del repositorio. Esto pasa con frecuencia ya que la 77 | comunidad de Rust es muy activa, por lo tanto cada noche una nueva 78 | versión del canal `Nightly` se produce, es decir, todos los días se 79 | libera una nueva versión con el *hash* del último commit aceptado dentro 80 | de `Nightly`, la rama `master` durante el transcurso del día podría 81 | verse algo así: 82 | 83 | `nightly: * - - * - - *` 84 | 85 | > Cada `*` representa un *commit*. 86 | 87 | Como los ciclos de liberación son fijos cada seis semanas el equipo de 88 | desarrollo de Rust se prepara para liberar una nueva versión, antes que 89 | nada primero deben migrar los cambios, por lo que la rama `beta` sale 90 | de la rama `master` y con eso tendremos nuestra liberación `beta`. 91 | 92 | ```ignore 93 | nightly: * - - * - - * 94 | | 95 | beta: * 96 | ``` 97 | 98 | La mayoría de los usuarios de Rust no utiliza este canal de forma 99 | activa, en su lugar utilizan *Sistemas de Integración Continua* para 100 | detectar cualquier posible regresión o error. Mientras esto ocurre, la 101 | rama `master` continúa actualizandose. 102 | 103 | ```ignore 104 | nightly: * - - * - - * - - * - - * 105 | | 106 | beta: * 107 | ``` 108 | 109 | En caso de que una regresión se encuentre las cosas apuntan a nuestro 110 | favor, pues la edición `beta` primero fue probada antes de enviar los 111 | cambios a la versión estable, lo que se hace en estos casos es aplicar 112 | un parche en la rama `master` y después migrarlo a la rama `beta`. 113 | 114 | ```ignore 115 | nightly: * - - * - - * - - * - - * - - * 116 | | 117 | beta: * - - - - - - - - * 118 | ``` 119 | 120 | Seis semanas después de la liberación de la rama `beta` es tiempo de 121 | enviar una nueva versión estable, por lo que una rama llamada `stable` 122 | saldrá de la rama `beta`: 123 | 124 | ```ignore 125 | nightly: * - - * - - * - - * - - * - - * - * - * 126 | | 127 | beta: * - - - - - - - - * 128 | | 129 | stable: * 130 | ``` 131 | 132 | Bien, una nueva versión de Rust está lista para usarse, pero tenemos 133 | que considear algo y es que han pasado 6 semanas, por lo que una nueva 134 | versión `beta` viene en camino, por lo tanto cada que se libera una 135 | versión estable, se crea una nueva versión beta. 136 | 137 | ## Herramientas de desarrollo para Rust 138 | 139 | * Racer (Nightly): `cargo install racer`. 140 | * rustfmt (Stable - Nightly): `rustup component add rustfmt`. 141 | * rust-doc (Stable - Nightly): `rustup component add rust-doc`. 142 | 143 | Si deseamos una integración propia con un IDE debemos de instalar 144 | [rls](https://github.com/rust-lang/rls) el cual es un servidor de 145 | lenguaje que nos ayudará con el resaltado de errores en tiempo real 146 | y nos proporcionará de otras funciones útiles. 147 | 148 | * RLS (Stable - Nightly): 149 | `rustup component add rls-preview rust-analysis rust-src` 150 | 151 | ¡Listo! Con esto tenemos nuestro entorno base para escribir programas en Rust. 152 | Ahora tenemos que elegir un IDE para empezar a desarrollar. 153 | 154 | Ve al capítulo **2.4** para ver nuestras recomendaciones o al capítulo **3** si 155 | deseas comenzar a escribir tus programas en Rust. -------------------------------------------------------------------------------- /src/PrimeraUnidad/01-cargo.md: -------------------------------------------------------------------------------- 1 | # Cargo ¿run? 2 | 3 | En el capítulo anterior creamos nuestro primer programa en Rust, un simple 4 | "Hola mundo". 5 | 6 | Pero pensemos un momento: ¿Y si deseamos crear un proyecto más grande?, ¿Qué tal 7 | si necesitamos crear una herramienta de línea de comandos más compleja? o quizá 8 | tenemos una gran idea para crear un API para usarse en Inteligencia Artificial. 9 | 10 | De una forma u otra necesitaremos una forma de manejar nuestro 11 | proyecto de manera eficiente, aquí entra `cargo` el gestor de paquetes 12 | de Rust. 13 | 14 | Cargo no solo se limita a ser un gestor de paquetes, también es 15 | un sistema de construcción y un excelente manejador de dependencias. 16 | Muchos programadores de Rust, a los cuales llamaremos *Rustáceos* en 17 | adelante (Derivado de la palabra *"Crustáceos"*) utilizan cargo para 18 | manejar sus proyectos ya que éste realiza muchas acciones por 19 | nosotros, descarga y compila las bibliotecas que son dependencias de 20 | nuestro código, le da formato a nuestro código si somos inexpertos en 21 | el tema, ejecuta pruebas y despliega nuestro código listo para enviarse 22 | a producción. 23 | 24 | Casi todos (por no decir la palabra *"Todos"*) los proyectos de Rust 25 | utilizan Cargo, si has instalado Rust utilizando el instalador oficial 26 | (`rustup`) entonces ya posees Cargo instalado y listo para usarse. 27 | 28 | ## Primer proyecto con Cargo 29 | 30 | Para crear un nuevo proyecto utilizando Cargo debemos ejecutar el 31 | siguiente comando: 32 | 33 | `$ cargo new --bin hola_cargo` 34 | 35 | Esto creará un nuevo proyecto de Cargo, si entramos en el directorio 36 | creado nos daremos cuenta que dentro hay varios archivos, un directorio 37 | y que se ha inicializado un nuevo repositorio con la herramienta `git`. 38 | 39 | Vamos a editar el archivo más llamativo del directorio llamado 40 | `Cargo.toml`: 41 | 42 | ```toml 43 | [package] 44 | name = "hola_cargo" 45 | version = "0.1.0" 46 | authors = ["nombre "] 47 | edition = "2018" 48 | 49 | [dependencies] 50 | ``` 51 | La primera línea del archivo es la sección `[package]` que indicará 52 | todos los detalles al momento de configurar un paquete de Cargo. 53 | 54 | Las siguientes líneas contienen información necesaria para poder 55 | construir y compilar el paquete en cuestión: 56 | 57 | * Nombre del paquete o `crate`. 58 | * Versión del paquete 59 | * Autor o autores del paquete 60 | * La edición de Rust (Hablaremos más adelante de eso). 61 | 62 | La siguiente sección se llama `[dependencies]`, debajo de esta se 63 | colocarán todas las dependencias requeridas para construir nuestro 64 | paquete de Rust, las usaremos más adelante. 65 | 66 | Como mencionamos más arriba, cargo genera un directorio de nombre `src` 67 | en el cual se incluye un archivo llamado `main.rs`, este archivo en 68 | cuestión contiene un "Hello World" dentro. 69 | 70 | Cargo asume que *TODOS* tus archivos de código fuente se encontrarán 71 | dentro del directorio `src/` ya que el directorio raíz del proyecto solo 72 | estará dedicado a información acerca del mismo, véase archivos `README`, 73 | `LICENSE` o las configuraciones escritas en TOML. 74 | 75 | ## Ejecutar proyectos utilizando cargo 76 | 77 | Si deseamos construir un proyecto utilizando Cargo solo es necesario 78 | escribir en nuestra terminal (dentro del directorio de nuestro 79 | proyecto): 80 | 81 | `$ cargo build` 82 | 83 | La saluda de la terminal nos debería mostrar una salida indicandonos si 84 | nuestro proyecto se pudo construir o si falló en algún punto: 85 | 86 | ```ignore 87 | Compiling hola_cargo v0.1.0 (/home/FutureLab/Escritorio/hola_cargo) 88 | Finished dev [unoptimized + debuginfo] target(s) in 0.39s 89 | ``` 90 | 91 | Cuando le damos la instrucción `build` a cargo éste creará un binario 92 | ejecutable en un nuevo árbol de directorios, específicamente dentro 93 | de `target/debug/`. 94 | 95 | Además de compilar un binario ejecutable Cargo también descargará y 96 | compilará las dependencias necesarias para nuestro proyecto, al mismo 97 | tiempo creará un archivo nuevo llamado `Cargo.lock`, no te alarmes, 98 | este archivo vigilará las versiones de tus dependencias. 99 | 100 | Si bien podríamos ejecutar los binarios desde su ruta con 101 | `$ ./target/debug/hola_cargo` esto es ineficiente, por lo que cargo 102 | tiene otra función para compilar y ejecutar nuestros proyectos en un 103 | solo comando: 104 | 105 | `$ cargo run` 106 | 107 | Si ejecutamos esta orden, Cargo buscará los archivos `.rs` dentro de 108 | nuestro directorio `src/`, los compilará e inmediatamente después los 109 | ejecutará si no encontró problema alguno. 110 | 111 | ```ignore 112 | Finished dev [unoptimized + debuginfo] target(s) in 0.01s 113 | Running `target/debug/hola_cargo` 114 | Hello, world! 115 | ``` 116 | 117 | Cargo posee una variedad de comandos entre ellos: 118 | 119 | * `check` => Se encarga de revisar que el código compile sin producir 120 | ejecutables. 121 | * `clean` => Elimina el directorio `target/`. 122 | * `doc` => Construye el paquete y sus dependencias con documentación. 123 | * `init` => Crea un nuevo proyecto en un directorio existente. 124 | * `test` => Ejecuta las pruebas. 125 | * `bench` => Ejecuta puntos de referencia. 126 | * `update` => Actualiza las dependencias de `Cargo.lock`. 127 | * `search` => Busca `crates` en el registro. 128 | * `publish` => Publica el paquete actual al registro. 129 | * `install` => Instala un binario de Rust en `$HOME/.cargo/bin`. 130 | * `uninstall` => Desinstala un binario de Rust. 131 | 132 | La ventaja de Cargo es que los comandos que se pueden ejecutar son 133 | independientes de cualquier plataforma por lo que funciona de la 134 | misma manera en Windows, MacOS y Gnu/Linux. 135 | 136 | ## Liberar un paquete 137 | 138 | Cuando hayas terminado tu proyecto solo necesitarás la bandera 139 | `--release` para generar un binario optimizado, esto generará un 140 | binario ejecutable en el directorio `target/release`. 141 | 142 | ## Fin de la lección 143 | 144 | Por ahora has aprendido a utilizar Cargo y a crear un pequeño hola mundo 145 | en Rust, pero imprimir mensajes de ese tipo en la consola no es divertido 146 | por lo que en el siguiente capítulo crearemos un programa llamado 147 | *"FizzBuzz"* el cual es una pregunta utilizada en las entrevistas de 148 | programación. 149 | 150 | ¡Prepárate para comenzar a utilizar Cargo de verdad! -------------------------------------------------------------------------------- /src/images/rocket/panics.svg: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 6 | 7 | 10 | 13 | 16 | 17 | 36 | 38 | 40 | 42 | 43 | 45 | 48 | 51 | 52 | 53 | 54 | 56 | 59 | 60 | 61 | 62 | 64 | 67 | 68 | 70 | 71 | -------------------------------------------------------------------------------- /src/images/rocket/not_desired_behavior.svg: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 6 | 7 | 10 | 13 | 16 | 17 | 36 | 38 | 40 | 42 | 43 | 44 | 45 | 46 | 47 | 48 | 49 | 50 | 52 | 56 | 60 | 61 | 62 | 64 | 67 | 68 | 70 | 73 | 74 | 75 | 76 | -------------------------------------------------------------------------------- /src/Introduccion/01-linux.md: -------------------------------------------------------------------------------- 1 | # Instalación en Gnu/Linux 2 | 3 | La instalación en Gnu/Linux es la instalación más utilizada por los 4 | programadores del lenguaje Rust. 5 | 6 | Antes de empezar, toma un aviso de nosotros, muchas distribuciones de GNU/Linux 7 | ya poseen Rust y sus herramientas en los repositorios oficiales, si bien esto 8 | lleva a una instalación rápida las versiones de Rust que ofrecen pueden no 9 | estar en su versión más actual, excluyendo al usuario de la mayor parte de 10 | características nuevas que las actualizaciones pueden ofrecer. 11 | 12 | Puedes instalar desde la terminal provista por tu sistema operativo ejecutando 13 | el siguiente comando: 14 | 15 | `curl https://sh.rustup.rs -sSf | sh` 16 | 17 | Con esto descargaremos la versión más reciente de Rustup y procederemos con la 18 | instalación del lenguaje. 19 | 20 | No te preocupes si resulta confuso al inicio, el instalador de Rust 21 | te guiará paso a paso en el proceso. 22 | 23 | Si te consideras un novato en el lenguaje te recomendamos mantener los 24 | ajustes de instalación por defecto. 25 | 26 | Para actualizar tus herramientas de Rust necesitaras ejecutar el comando 27 | `$ rustup update`. 28 | 29 | ## Configurar la variable de entorno 30 | 31 | Al proceder con la instalación de Rust, todas las herramientas se 32 | almacenarán en el directorio `~/.cargo/bin`, ahí encontrarás todo el 33 | software que has descargado como `rustc`, `cargo` y `rustup`. 34 | 35 | Es opcional (y conveniente) incluir este directorio en una variable de 36 | entorno, durante la instalación `rustup` intentará configurar dicha 37 | variable definida como `PATH`. Como todas las líneas de comandos son 38 | diferentes las modificaciones hacia `PATH` podrían no surtir efecto 39 | hasta que se reinicie la consola, al salir de la sesión o puede no 40 | funcionar del todo, por lo que como usuario te tocará corregir este 41 | error por tus medios. 42 | 43 | Si no funciona la modificación de la variable `PATH` en el archivo `~/.profile` 44 | puedes pegar la siguiente línea en tu archivo `.bashrc` (o cualquier archivo de 45 | configuración de la shell que utilices). 46 | 47 | ```sh 48 | export PATH="$HOME/.cargo/bin:$PATH" 49 | ``` 50 | 51 | Si deseas empaparte con un poco más de información continúa leyendo o 52 | si consideras que la instalación es suficiente puedes pasar al siguiente 53 | capítulo. 54 | 55 | ## Los canales de actualización 56 | 57 | El desarrollo de Rust es muy activo, por lo que opera en tres canales de 58 | distribución: 59 | 60 | * Stable 61 | * Beta 62 | * Nightly 63 | 64 | Si eres un usuario novel te recomendamos mantenerte en el canal `Stable`. 65 | 66 | > Los canales `Beta` o `Nightly` son para aquellos valientes que desean 67 | > probar características más recientes del lenguaje aunque a veces son 68 | > necesarios para algunas herramientas. 69 | 70 | Vamos a explicar/traducir el proceso de liberación de Rust como viene 71 | explicado en el [libro](https://doc.rust-lang.org/book/appendix-07-nightly-rust.html?highlight=channel#choo-choo-release-channels-and-riding-the-trains): 72 | 73 | > Necesitarás conocimientos básicos de Git para entender algunas cosas. 74 | 75 | Cada vez que se añade una característica a Rust, se crea un *commit* en 76 | la rama `master` del repositorio. Esto pasa con frecuencia ya que la 77 | comunidad de Rust es muy activa, por lo tanto cada noche una nueva 78 | versión del canal `Nightly` se produce, es decir, todos los días se 79 | libera una nueva versión con el *hash* del último commit aceptado dentro 80 | de `Nightly`, la rama `master` durante el transcurso del día podría 81 | verse algo así: 82 | 83 | `nightly: * - - * - - *` 84 | 85 | > Cada `*` representa un *commit*. 86 | 87 | Como los ciclos de liberación son fijos cada seis semanas el equipo de 88 | desarrollo de Rust se prepara para liberar una nueva versión, antes que 89 | nada primero deben migrar los cambios, por lo que la rama `beta` sale 90 | de la rama `master` y con eso tendremos nuestra liberación `beta`. 91 | 92 | ```ignore 93 | nightly: * - - * - - * 94 | | 95 | beta: * 96 | ``` 97 | 98 | La mayoría de los usuarios de Rust no utiliza este canal de forma 99 | activa, en su lugar utilizan *Sistemas de Integración Continua* para 100 | detectar cualquier posible regresión o error. Mientras esto ocurre, la 101 | rama `master` continúa actualizandose. 102 | 103 | ```ignore 104 | nightly: * - - * - - * - - * - - * 105 | | 106 | beta: * 107 | ``` 108 | 109 | En caso de que una regresión se encuentre las cosas apuntan a nuestro 110 | favor, pues la edición `beta` primero fue probada antes de enviar los 111 | cambios a la versión estable, lo que se hace en estos casos es aplicar 112 | un parche en la rama `master` y después migrarlo a la rama `beta`. 113 | 114 | ```ignore 115 | nightly: * - - * - - * - - * - - * - - * 116 | | 117 | beta: * - - - - - - - - * 118 | ``` 119 | 120 | Seis semanas después de la liberación de la rama `beta` es tiempo de 121 | enviar una nueva versión estable, por lo que una rama llamada `stable` 122 | saldrá de la rama `beta`: 123 | 124 | ```ignore 125 | nightly: * - - * - - * - - * - - * - - * - * - * 126 | | 127 | beta: * - - - - - - - - * 128 | | 129 | stable: * 130 | ``` 131 | 132 | Bien, una nueva versión de Rust está lista para usarse, pero tenemos 133 | que considear algo y es que han pasado 6 semanas, por lo que una nueva 134 | versión `beta` viene en camino, por lo tanto cada que se libera una 135 | versión estable, se crea una nueva versión beta. 136 | 137 | ## Herramientas de desarrollo para Rust 138 | 139 | * Racer (Nightly): `cargo install racer`. 140 | * rustfmt (Stable - Nightly): `rustup component add rustfmt`. 141 | * rust-doc (Stable - Nightly): `rustup component add rust-doc`. 142 | 143 | Si deseamos una integración propia con un IDE debemos de instalar 144 | [rls](https://github.com/rust-lang/rls) el cual es un servidor de 145 | lenguaje que nos ayudará con el resaltado de errores en tiempo real 146 | y nos proporcionará de otras funciones útiles. 147 | 148 | * RLS (Stable - Nightly): 149 | `rustup component add rls-preview rust-analysis rust-src` 150 | 151 | ¡Listo! Con esto tenemos nuestro entorno base para escribir programas en Rust. 152 | Ahora tenemos que elegir un IDE para empezar a desarrollar. 153 | 154 | Ve al capítulo **2.4** para ver nuestras recomendaciones o al capítulo **3** si 155 | deseas comenzar a escribir tus programas en Rust. -------------------------------------------------------------------------------- /src/PrimeraUnidad/04-variables-y-tipos.md: -------------------------------------------------------------------------------- 1 | # Variables y tipos 2 | 3 | Por muy gracioso que suene, una de las primeras cosas que los programadores 4 | buscan al aprender un nuevo lenguaje es la manera que tiene de declarar 5 | variables y sus respectivos tipos, en este capítulo aprenderemos a declarar 6 | variables y a manejar diferentes tipos de datos en Rust. 7 | 8 | Así mismo discutiremos los tipos primitivos, cuando *"tipear"* una variable o 9 | no, el alcance de las variables y otros tratos especiales que posee rust como la 10 | *inmutabilidad*. 11 | 12 | ## Comentarios 13 | 14 | En un escenario ideal el código debería auto-documentarse por medio de las 15 | buenas prácticas como los nombres descriptivos de variables, un estilo de 16 | código limpio y una estructura impecable, aun así, existen casos donde se 17 | necesita de un elemento extra para explicar o justificar la estructura de una 18 | o varias partes de nuestro programa. 19 | 20 | Rust sigue la forma de comentar de nuestro querido lenguaje C, por lo tanto 21 | tenemos dos formas de comentar líneas de código: 22 | 23 | * `//` Comentarios con doble barra para una sola línea. 24 | 25 | ```rust,ignore 26 | // Esto es un comentario y no se compilará 27 | ``` 28 | 29 | * `/* */` Comentarios del tipo bloque para múltiples líneas. 30 | 31 | ```rust,ignore 32 | /* 33 | Esto 34 | es 35 | un 36 | comentario 37 | largo 38 | */ 39 | ``` 40 | 41 | El estilo recomendado por la guía oficial de Rust es utilizar el comentario de 42 | doble barra, incluso para varias líneas en caso de necesitar explicar tu código. 43 | 44 | Procura utilizar el comentario multilínea solamente para comentar código. 45 | 46 | > rust-doc también ofrece comentarios para documentación utilizando tres barras 47 | > `///`, estos son útiles en proyectos grandes que necesitarán de algún tipo de 48 | > documentación oficial además, en estos comentarios podemos utilizar sintáxis 49 | > markdown para mejorar la legibilidad de nuestra documentación. 50 | 51 | 52 | ## Asignación de variables 53 | 54 | Hasta ahora hemos visto varios tipos de valores, hemos visto cadenas, números 55 | enteros, etc. Pero no debemos de confundir los valores con los objetos ni las 56 | variables. 57 | 58 | Tendremos que dejar algo muy claro desde el principio, la asignación de 59 | variables es diferente en Rust si lo comparamos con otros lenguajes, esto es 60 | para preservar 3 carácteristicas que hacen especial al lenguaje: 61 | 62 | * **Seguridad** 63 | * **Eficiencia** 64 | * **Concisión** 65 | 66 | A diferencia de otros lenguajes (como *JavaScript* o *Ruby*), Rust necesita un 67 | poco más de planeación al escribir código pues necesitarás dictar los tipos de 68 | los parámetros de tus funciones, de sus valores de retorno y de tus variables. 69 | 70 | Por lo tanto Rust es un lenguaje *"Estáticamente tipado"* o de 71 | *"Tipado estático"* lo que significa que el compilador deberá conocer el tipo 72 | de los datos antes del tiempo de ejecución, este método que viene de lenguajes 73 | veteranos como C o C++ ha sido rediseñado en Rust, pues el compilador revisará 74 | que todos los caminos posibles de ejecución usarán valores solo de manera consistente con sus tipos. Esto permite que Rust detecte muchos errores de programación antes de tiempo, y es crucial para garantizar de seguridad de Rust. 75 | 76 | Por lo tanto, en lugar de utilizar un intérprete o un compilador en tiempo real 77 | como lo harían lenguajes como *Julia* o *LuaJIT (Lua Just In Time Compiler)*, 78 | Rust fue diseñado para utilizar algo llamado *"Compilación anticipada"* es decir 79 | una traducción completa de todo tu programa a código máquina antes de que 80 | comience a ejecutarse, por ello los tipos de datos que Rust utilizar ayudan al 81 | compilador a elegir una representación adecuada en el bajo nivel. 82 | 83 | Cuando Rust compila el código fuente el ejecutable resultante solo contiene 84 | objetos que tengan una dirección de memoria y un valor. Dichos objetos no poseen 85 | un nombre definido, pero estos mismos objetos necesitan de un identificador en 86 | el código fuente para poder referenciarlos más tarde. 87 | 88 | En Rust necesitaremos de la palabra reservada `let` para declarar cualquier 89 | variable, por ejemplo: 90 | 91 | ```rust,ignore 92 | let edad = 20; 93 | let nombre = "Future Lab"; 94 | let flotante = 3.1415; 95 | ``` 96 | 97 | ### Variables ¿inmutables? 98 | 99 | Tus ojos no te están engañando, las variables en Rust son inmutables por 100 | defecto, esto se hace para preservar la seguridad en Rust, pero esto no es el 101 | fin del mundo, Rust nos ofrece la opción de mutar las variables a nuestro gusto 102 | siempre y cuando cumplamos con ciertas reglas impuestas por el compilador. 103 | 104 | > Rust no es el primer lenguaje en hacer esto, muchos lenguajes funcionales 105 | > poseen esta característica. De hecho en los lenguajes 100% funcionales la 106 | > mutabilidad de las variables no está permitida. 107 | 108 | Veamos este pequeño ejemplo para ilustrar lo anterior: 109 | 110 | Ejemplo 1.0 111 | ```rust,ignore 112 | {{#include ../code/rust/inmutvars.rs}} 113 | ``` 114 | 115 | El siguiente código producirá un error de compilación específicamente este: 116 | 117 | ```ignore 118 | error[E0384]: cannot assign twice to immutable variable `edad` 119 | --> src/main.rs:4:5 120 | | 121 | 2 | let edad = 10; 122 | | ---- first assignment to `edad` 123 | 3 | 124 | 4 | edad = 5; 125 | | ^^^^^^^^ cannot assign twice to immutable variable 126 | ``` 127 | 128 | Rust aplica la sabiduría que muchos programadores necesitan: 129 | *"Muchos errores surgen de cambios involuntarios o incorrectos de las* 130 | *variables, así que no permiré que el código cambie cualquier valor a menos que* 131 | *lo haya permitido explícitamente."* 132 | 133 | Si deseamos una variable mutable necesitaríamos indicarle a Rust específicamente 134 | que la variable es mutable, si deseamos hacer algo así necesitamos hacer lo 135 | siguiente: 136 | 137 | Ejemplo 1.1 138 | 139 | ```rust,ignore 140 | {{#include ../code/rust/mutvars.rs}} 141 | ``` 142 | 143 | Esto debería imprimir el siguiente mensaje en pantalla: 144 | 145 | ```ignore 146 | Tienes 20 años 147 | Ahora tienes 21 años 148 | ``` 149 | 150 | Para darnos una mejor idea de como funciona la mutabilidad de las variables 151 | aquí tenemos un ejemplo del código 1.0 escrito en C: 152 | 153 | ```c,ignore 154 | {{#include ../code/c/inmutvars.c}} 155 | ``` 156 | 157 | > No intentes compilarlo, no funcionará. 158 | 159 | A comparación de las variables mutables en el ejemplo 1.1: 160 | 161 | ```c,ignore 162 | {{#include ../code/c/mutvars.c}} 163 | ``` -------------------------------------------------------------------------------- /src/images/rocket/does_not_compile.svg: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 6 | 7 | 10 | 13 | 16 | 17 | 36 | 38 | 40 | 42 | 43 | 45 | 48 | 51 | 52 | 54 | 55 | 57 | 60 | 63 | 64 | 65 | 71 | 72 | 73 | -------------------------------------------------------------------------------- /src/Introduccion/02-ide.md: -------------------------------------------------------------------------------- 1 | # ¡Hora de elegir un editor! 2 | 3 | Bien, empecemos con las malas noticias: Rust no tiene un IDE oficial, de hecho 4 | no existen IDEs 100% funcionales que estén dedicados enteramente a Rust, por 5 | lo que necesitarás elegir entre los editores de texto que rondan por la 6 | comunidad o si ya utilizas uno necesitarás descargar los plugins necesarios. 7 | 8 | > Todos los datos de esta página fueron extraidos de la página 9 | > [ARE WE IDE YET?](https://areweideyet.com/). Nosotros solo simplificaremos 10 | > lo establecido ahí. 11 | 12 | Se indicarán los requerimientos entre paréntesis. 13 | 14 | ## ATOM 15 | 16 | Atom es un editor de texto desarrollado por GitHub utilizando la biblioteca 17 | *Electron*, es extensible y fácil de utilizar. 18 | 19 | Eficiencia de atom en Rust: 20 | 21 | * Resaltado de sintaxis (Plugin) 22 | * Snippets (Plugin) 23 | * Autocompletado (Plugin) 24 | * Linternas (Plugin) 25 | * Formato de código (Plugin) 26 | * Ir a la definición (Plugin) 27 | * Depuración 28 | * Tooltips de documentación (Plugin) 29 | 30 | ### Plugins de ATOM para Rust 31 | 32 | * [language-rust](https://atom.io/packages/language-rust). 33 | * [ide-rust](https://atom.io/packages/ide-rust) <- Este plugin instala 34 | el plugin `language-rust` y `atom-ide-ui`, provee al usuario con 35 | `rustfmt`, `racer` y funciones de IDE utilizando el `rls`. 36 | * [linter-rust](https://atom.io/packages/linter-rust) 37 | depende del plugin `linter`. 38 | * [racer](https://atom.io/packages/racer) 39 | * [rustfmt](https://atom.io/packages/rustfmt) 40 | * [tokamak](https://vertexclique.github.io/tokamak/) 41 | * [build-cargo](https://atom.io/packages/build-cargo) depende de 42 | `build` y `linter`. 43 | * [atom-beautify](https://atom.io/packages/atom-beautify) 44 | * [languageserver-rust](https://atom.io/packages/languageserver-rust) 45 | 46 | --- 47 | 48 | ## Emacs 49 | 50 | Emacs es un editor de texto extensible, personalizable y libre, escrito 51 | en Lisp. 52 | 53 | Eficiencia de emacs en Rust: 54 | 55 | * Resaltado de sintaxis (Plugin) 56 | * Snippets (Plugin) 57 | * Autocompletado (Plugin + Racer) 58 | * Linternas (Plugin) 59 | * Formato de código (Plugin) 60 | * Ir a la definición (Plugin + Racer) 61 | * Depuración 62 | * Tooltips de documentación (Plugin + Racer) 63 | 64 | ### Plugins de Emacs para Rust 65 | 66 | * [rust-mode](https://github.com/rust-lang/rust-mode) 67 | * [flycheck-rust](https://github.com/flycheck/flycheck-rust) 68 | * [emacs-racer](https://github.com/racer-rust/emacs-racer) 69 | * [rust-snippets](https://github.com/freebroccolo/rust-snippets) 70 | 71 | --- 72 | 73 | ## Sublime text 2/3 74 | 75 | Sublime text es un editor de texto escrito en C++, extensible y poderoso 76 | para editar código fuente. 77 | 78 | Eficiencia de sublime text en Rust: 79 | 80 | * Resaltado de sintaxis 81 | * Snippets 82 | * Autocompletado (Plugin + Racer) 83 | * Linternas 84 | * Formato de código (Plugin) 85 | * Ir a la definición (Plugin + Racer) 86 | * Depuración 87 | * Tooltips de documentación 88 | 89 | ### Plugins de Sublime Text para Rust 90 | 91 | * [TOML](https://packagecontrol.io/packages/TOML) 92 | * [Rust Enhanced](https://packagecontrol.io/packages/Rust%20Enhanced) 93 | * [YouCompleteMePlugin](https://packagecontrol.io/packages/YcmdCompletion) 94 | * [BeautifyRust](https://packagecontrol.io/packages/BeautifyRust) 95 | 96 | --- 97 | 98 | ## Vim/Neovim 99 | Vim es un editor de texto extensible, altamente personalizable y útil 100 | para casi cualquier propósito, se incluye como reemplazo de `vi` en la 101 | mayoría de los sistemas operativos tipo UNIX. 102 | 103 | Eficiencia de Vim/Neovim en Rust: 104 | 105 | * Resaltado de sintaxis (Plugin) 106 | * Snippets (Plugin) 107 | * Autocompletado (Plugin + Racer) 108 | * Linternas (Plugin + Racer) 109 | * Formato de código (Plugin) 110 | * Ir a la definición (Plugin + Racer) 111 | * Depuración 112 | * Tooltips de documentación (Plugin + Racer) 113 | 114 | ### Plugins de Vim/Neovim para Rust 115 | 116 | * [rust.vim](https://github.com/rust-lang/rust.vim) 117 | * [YouCompleteMe-rust](http://blog.jwilm.io/youcompleteme-rust) 118 | * [vim-racer](https://github.com/racer-rust/vim-racer) 119 | * [syntastic](https://github.com/scrooloose/syntastic) 120 | * [UltiSnips](https://github.com/sirver/ultisnips) 121 | 122 | --- 123 | 124 | ## VSCode / Visual Studio Code / VSCodium 125 | 126 | * VSCode es una herramienta que combina la simplicidad de un editor de 127 | texto con las necesidades de los desarrolladores. (VSCode es el proyecto 128 | padre de Visual Studio Code y VSCodium). 129 | 130 | * Visual Studio Code es un editor derivado de VSCode el cual es 131 | clonado por Microsoft y modificado con telemetría, llaves de API 132 | cerradas y herramientas de integración avanzada. 133 | 134 | * VSCodium es un derivado de VSCode el cual es una compilación del mismo 135 | que provee un editor 100 FLOSS (Free, Libre and Open Source Software). 136 | Por lo que este no contiene telemetría o rastro alguno de la marca de 137 | Microsoft, ideal para los entusiastas del software libre. 138 | 139 | Eficiencia de VSCode en Rust: 140 | 141 | * Resaltado de sintaxis (Plugin) 142 | * Snippets (Plugin) 143 | * Autocompletado (Plugin + Racer) 144 | * Linternas (Plugin) 145 | * Formato de código (Plugin) 146 | * Ir a la definición (Plugin + Racer) 147 | * Depuración (Plugin) 148 | * Tooltips de documentación (Plugin + Racer) 149 | 150 | ### Plugins de VSCode para Rust 151 | 152 | * [Rust (RLS)](https://marketplace.visualstudio.com/items?itemName=rust-lang.rust) 153 | * [CodeLLDB](https://marketplace.visualstudio.com/items?itemName=vadimcn.vscode-lldb) 154 | * [Debug](https://marketplace.visualstudio.com/items?itemName=webfreak.debug) 155 | * [TOML Language Support](https://marketplace.visualstudio.com/items?itemName=be5invis.toml) 156 | 157 | --- 158 | 159 | ## Eclipse 160 | 161 | Eclipse es un Entorno de Desarrollo Integrado (IDE) escrito en Java 162 | el cual está compuesto por un conjunto de herramientas que le garantizan 163 | extensibilidad y poder para el desarrollo multiplataforma. 164 | 165 | Eficiencia de Eclipse en Rust: 166 | 167 | * Resaltado de sintaxis (Plugin) 168 | * Snippets (Plugin) 169 | * Autocompletado (Plugin) 170 | * Linternas (Plugin) 171 | * Formato de código (Plugin) 172 | * Ir a la definición (Plugin) 173 | * Depuración (Plugin) 174 | * Tooltips de documentación (Plugin) 175 | 176 | ### Plugins de Eclipse para Rust 177 | 178 | * [Corrosion](https://github.com/eclipse/corrosion) 179 | 180 | --- 181 | 182 | ## IntelliJ IDEA 183 | 184 | IntelliJ IDEA es un IDE desarrollado por la compañía JetBrains hecha en 185 | Kotlin, Java y Python, cuenta con las ediciones de pago y comunitaria. 186 | 187 | Eficiencia de IntelliJ en Rust: 188 | 189 | * Resaltado de sintaxis (Plugin) 190 | * Snippets (Plugin) 191 | * Autocompletado (Plugin) 192 | * Linternas (Plugin) 193 | * Formato de código (Plugin) 194 | * Ir a la definición (Plugin) 195 | * Depuración (Plugin) 196 | * Tooltips de documentación (Plugin) 197 | 198 | ### Plugins de IntelliJ para Rust 199 | 200 | * [intellij-rust](https://intellij-rust.github.io/) 201 | 202 | --- 203 | 204 | ## Visual Studio 205 | 206 | Visual Studio es un IDE disponible para las plataformas de Microsoft 207 | Windows y Mac OS el cual posee todas las características para 208 | desarrollar software en Android, iOS, Windows, Web y Cloud Computing. 209 | 210 | Eficiencia de Visual Studio en Rust: 211 | 212 | * Resaltado de sintaxis 213 | * Snippets 214 | * Autocompletado 215 | * Linternas 216 | * Formato de código 217 | * Ir a la definición (Plugin) 218 | * Depuración (Plugin) 219 | * Tooltips de documentación 220 | 221 | ### Plugins de Visual Studio para Rust 222 | 223 | * [Visual Rust](https://github.com/PistonDevelopers/VisualRust) 224 | 225 | --- 226 | 227 | ## GNOME Builder 228 | 229 | GNOME Builder es un IDE desarrollado en C para la plataforma Gnu/Linux 230 | el cual cuenta con búsqueda global, autocompletado, mini-mapa, 231 | documentación y edición avanzada. 232 | 233 | Eficiencia de Builder en Rust: 234 | 235 | * Resaltado de sintaxis 236 | * Snippets 237 | * Autocompletado 238 | * Linternas 239 | * Formato de código 240 | * Ir a la definición 241 | * Depuración 242 | * Tooltips de documentación 243 | 244 | --- 245 | 246 | ## Otros editores que soportan Rust: 247 | 248 | * BBEdit 249 | * Midnight Commander 250 | * Geany 251 | * gedit 252 | * Kate 253 | * Textadept 254 | * Ride 255 | * Solid Oak 256 | 257 | --- -------------------------------------------------------------------------------- /src/PrimeraUnidad/02-fizzbuzz.md: -------------------------------------------------------------------------------- 1 | # Creando un programa FizzRust...FizzBuzz. 2 | 3 | ## ⚠️ LECTURA PROLONGADA ⚠️ 4 | 5 | Hemos aprendo a las bases para utilizar nuestras herramientas de Rust y creamos 6 | nuestro primer "Hola Mundo" en poco tiempo, pero ahora pasemos a crear un 7 | programa más interesante, un programa llamado *"FizzBuzz"*. 8 | 9 | ## ¿Fizz..que? 10 | 11 | FizzBuzz es un juego que se utiliza con los niños para mejorar su 12 | capacidad de aplicar una división de manera mental. No, no planeamos 13 | tratarte como un niño pues esta prueba también se utiliza en las 14 | entrevistas de programación y funciona como un filtro, normalmente se 15 | les pide lo siguiente a los candidatos: 16 | 17 | *"Escriba un programa que imprima los números desde 1 hasta 100. Pero* 18 | *en cada número que sea múltiplo de 3 se deberá imprimir "Fizz" en el* 19 | *lugar del número, el mismo caso para los números que sean múltiplos de* 20 | *5. Por cada número que sea múltiplo de 3 y 5 se deberá imprimir* 21 | *FizzBuzz"* 22 | 23 | Por más simple que parezca la prueba, muchos programadores no logran 24 | pasarla pues no es un patrón que se vea dentro de las enseñanzas clásicas 25 | y por que no es posible representar las pruebas de manera directa y 26 | simple sin necesidad de duplicar algo. 27 | 28 | Aun así no nos vamos a adentrar en la complejidad de la prueba y 29 | explicar los árboles de desiciones en este capítulo sería desviarnos 30 | del objetivo principal, existen diferentes formas de resolver un 31 | problema FizzBuzz en diferentes lenguajes, aquí puedes ver algunos ejemplos. 32 | 33 | #### Python 34 | 35 | ```python 36 | {{#include ../code/python/fizzbuzz.py}} 37 | ``` 38 | 39 | #### C (ANSI + Kernel Coding Style) 40 | ```c 41 | {{#include ../code/c/fizzbuzz.c}} 42 | ``` 43 | > El problema con este ejemplo es que no se ve un caso para el 44 | > "FizzBuzz". Nótese que no existe la impresión de una nueva línea 45 | > en el cuarto printf. Si el número es un múltiplo de 3 y 5 las 46 | > primeras dos condiciones se cumplen, por lo tanto ambos casos 47 | > se ejecutan. 48 | 49 | > Si deseas agregar un ejemplo de FizzBuzz al libro eres bienvenido, 50 | > solo abre un *Pull Request* que incluya el programa con tu lenguaje 51 | > de programación favorito :D 52 | 53 | Bien, ahora vamos a tomar la aproximación de Rust. En este proyecto crearemos 54 | el mismo programa pero con salida de colores y en el camino explicaremos por 55 | encima algunos conceptos base de programación en Rust. 56 | 57 | 58 | ## Preparando el proyecto 59 | 60 | Utilizando nuestros conocimientos previos lo primero que haremos será crear 61 | un nuevo proyecto utilizando Cargo, vamos a llamarlo FizzBuzz. 62 | 63 | `$ cargo new --bin fizzbuzz` 64 | 65 | Ahora entremos en el directorio creado por Cargo: 66 | 67 | `$ cd fizzbuzz` 68 | 69 | Vamos a editar el archivo `Cargo.toml` el cual se encuentra por defecto, en 70 | nuestro caso los programadores de Future Lab decidieron dejarlo de esta manera: 71 | 72 | ```toml 73 | [package] 74 | name = "fizzbuzz" 75 | version = "0.1.0" 76 | authors = ["Future Lab "] 77 | edition = "2018" 78 | 79 | [dependencies] 80 | ``` 81 | 82 | En la parte superior mencionamos que nuestro programa tendría una salida a 83 | terminal de colores, para esto necesitamos agregar un `crate` a nuestra 84 | sección `[dependencies]`. La crate que utilizaremos es 85 | [colored](https://github.com/mackwic/colored) un paquete de Rust que nos 86 | permite imprimir texto con decoraciones en la terminal. 87 | 88 | Nuestro archivo `Cargo.toml` debería quedar así: 89 | 90 | ```toml 91 | [package] 92 | name = "fizzbuzz" 93 | version = "0.1.0" 94 | authors = ["Future Lab "] 95 | edition = "2018" 96 | 97 | [dependencies] 98 | colored = "1.6" 99 | ``` 100 | 101 | Bien, tenemos las dependencias que necesitamos para nuestro programa en 102 | Rust, digámosle a Cargo que las descargue y las compile para poder utilizarlas 103 | en nuestro proyecto sin problema alguno con: 104 | 105 | `$ cargo build` 106 | 107 | Esto debería de descargar y compilar `colored` y dejarlo listo para usar: 108 | 109 | ```ignore 110 | Updating crates.io index 111 | Compiling lazy_static v1.2.0 112 | Compiling colored v1.6.1 113 | Compiling fizzbuzz v0.1.0 (/home/futurelab/Escritorio/fizzbuzz) 114 | Finished dev [unoptimized + debuginfo] target(s) in 13.38s 115 | ``` 116 | 117 | ## Escribir una base 118 | 119 | Utilizando el editor de tu preferencia abre el archivo `main.rs`, este es el 120 | archivo que vamos a modificar, elimina la línea que contiene el mensaje de 121 | impresión (`println!`) y procede a escribir el siguiente código, no te 122 | preocupes si no lo entiendes pues lo explicaremos a lo largo de este capítulo. 123 | 124 | {{#playpen ../code/rust/fizzbuzz.rs}} 125 | 126 | > No ejecutes este código aún, es una versión de pruebas que 127 | > modificaremos a lo largo de este y los siguientes capítulos. 128 | 129 | ## Comprendiendo el código 130 | 131 | ¿Que está pasando aquí? Hay muchos elementos nuevos (Claro, todo es nuevo 132 | a diferencia del macro `println!` que vimos en el capítulo pasado) por lo que 133 | vamos a volver a descomponer línea por línea todo el programa. 134 | 135 | Revisemos dentro de la función `main`, esta función es la misma que utilizamos 136 | en nuestro primer `hola mundo` por lo que no hay necesidad de explicarla así 137 | que nos dirigiremos a la segunda línea de nuestro código actual: 138 | 139 | ```rust,ignore 140 | {{#include ../code/rust/fizzbuzz.rs:2}} 141 | ``` 142 | 143 | ### El iterador 144 | 145 | Como mencionamos en el capítulo **2**, asumiremos que posees conocimientos 146 | básicos de programación por lo que debe ser evidente que esto es algo 147 | conocido como *"ciclo for"*, los exploraremos más adelante en el capítulo 148 | de control de flujo, por ahora vamos a dejar claras las bases de un 149 | ciclo `for` en Rust. 150 | 151 | Lo primero que podemos observar es que la sintaxis de los ciclos `for` 152 | no es similar a la utilizada en lenguajes como C, JavaScript o Java: 153 | 154 | ```c 155 | for (x = 0; x < 10; x++) { 156 | printf("%i\n", x); 157 | } 158 | ``` 159 | 160 | En su lugar (y en términos más abstractos) los ciclos `for` en Rust 161 | se ven algo así: 162 | 163 | ```rust,ignore 164 | for x in 0..5 { 165 | println!("{}", x); 166 | } 167 | ``` 168 | 169 | Si abstraemos los términos podríamos describirlos así: 170 | 171 | ```rust,ignore 172 | for variable in expresion { 173 | código 174 | } 175 | ``` 176 | 177 | Siendo "`expresion`" un iterador. En nuestro ejemplo elegimos el rango de 178 | `0..5`, esta expresión consta de un inicio y un fin y el ciclo realizará 179 | una iteración entre esos valores, aunque Rust posee rangos inclusivos, 180 | por defecto el límite superior es exclusivo, por lo tanto nuestro ciclo 181 | `for` imprimirá los valores del `0` al `4`, no hasta el número `5`. 182 | 183 | La razón por la que Rust no posee ciclos `for` con una sintaxis parecida 184 | a C es sencilla, al tener esa sintaxis se controla manualmente cada 185 | elemento del ciclo lo cual deja el código susceptible a errores *humanos*. 186 | 187 | Pero hay algo diferente en nuestro ciclo for, si volvemos por un momento 188 | a nuestro código podemos notar que no tenemos un valor definido como 189 | límite superior del ciclo: 190 | 191 | ```rust,ignore 192 | {{#include ../code/rust/fizzbuzz.rs:2}} 193 | ``` 194 | 195 | En su lugar tenemos una llave abierta, indicando el inicio de las 196 | instrucciones del ciclo. Esto es muy sencillo, cuando Rust encuentre 197 | un ciclo `for` de este tipo lo ejecutará infinitamente. 198 | 199 | Nos hemos equivocado a propósito, pues Rust posee una forma más sencilla 200 | de realizar ciclos infinitos. 201 | 202 | Por ahora continuaremos explorando la estructura del ciclo `for`: 203 | 204 | ```rust,ignore 205 | {{#include ../code/rust/fizzbuzz.rs:3:7}} 206 | ``` 207 | 208 | ### Múltiples casos, múltiples resultados. 209 | 210 | Aquí podemos ver otro elemento *"antes de tiempo"* que viene del control 211 | de flujo en Rust, en este caso `match`. 212 | 213 | `match` es el equivalente a `switch` en otros lenguajes de programación 214 | como C o C++, una alternativa a comparar y ejecutar los diferentes 215 | valores que puede tomar una variable. 216 | 217 | La estructura de la palabra clave `match` puede ser utilizada de formas 218 | complejas y aunque no explicaremos a fondo su uso por ahora, intentaremos 219 | explicarte como funciona `match` en el caso de nuestro código. 220 | 221 | Para que `match` funcione correctamente necesita una expresión para 222 | evaluar, como nosotros tenemos `x` como variable (declarada en el 223 | alcance del ciclo `for`) y ésta se encuentra en uso como iterador 224 | su valor mutará en cada *"vuelta"* del ciclo, en este caso `x` aumentará 225 | su valor en una unidad por iteración por lo que `x` será lo que 226 | evaluaremos. 227 | 228 | Dentro de los paréntesis tenemos dos operaciones que procesarán `x` y 229 | arrojarán un resultado que será enviado a cualquiera de los posibles 230 | casos dentro de `match`, en este caso nuestras dos operaciones son las 231 | siguientes: `x % 3` y `x % 5`. 232 | 233 | El operador `%` cumple la misma función que en otros lenguajes, retorna 234 | el residuo de la división entre dos números, sabiendo esto cada 235 | iteración comparará a `x` dos veces, regresando el residuo del valor de 236 | `x` dividido entre `3` y `5`, dependiendo del resultado se enviará 237 | a la pantalla el mensaje. 238 | 239 | Veamos la primera condición: 240 | 241 | ```rust,ignore 242 | {{#include ../code/rust/fizzbuzz.rs:4}} 243 | ``` 244 | Si el residuo resultante de la división de `x`/`3` **Y** `x`/`5` es 245 | igual a cero entonces se enviará a la pantalla el mensaje "FizzBuzz". 246 | 247 | --- 248 | 249 | En la segunda condición las cosas cambian un poco, podemos observar 250 | un elemento nuevo, un guión bajo (`_`), éste funciona de la misma 251 | manera que un `default:` funciona dentro de un `switch`. 252 | 253 | En este caso `_` funciona como un *"atrapa-todo"* en el cual caerán 254 | todos los resultados que no coincidan don las condiciones expresadas en 255 | los casos de `match`. Si observamos detenidamente el código podemos 256 | llegar a la conclusión de que `_` funcionará en caso de que 257 | la división de `x`/`3` ó `x`/`5` arrojen *cualquier valor diferente de 0* 258 | 259 | ```rust,ignore 260 | {{#include ../code/rust/fizzbuzz.rs:5:7}} 261 | ``` 262 | --- 263 | 264 | 265 | ### Agregando algo de color 266 | 267 | Bien, nuestro programa FizzBuzz funciona, en un ciclo infinito que 268 | se ejecutará hasta que nuestra computadora tenga la necesidad 269 | de detenerlo, más tarde arreglaremos ese problema, por ahora 270 | vamos a darle un poco de color a la salida del programa. Para esto 271 | utilizaremos un crate llamado `colored`, la misma que agregamos 272 | al inicio de este capítulo, el uso es sencillo, por ejemplo, podemos 273 | imprimir "Hola Rust" en color rojo: 274 | 275 | ```rust,ignore 276 | {{#include ../code/rust/hello-color.rs}} 277 | ``` 278 | > Eliminamos la opción de ejecución en este ejemplo, pues el navegador 279 | > no soporta la impresión de texto de color. 280 | 281 | Hagamos una ligera modificación, cuando el programa tenga que imprimir 282 | *"Fizz"*, lo hará en un color rojo, en caso de que necesite imprimir 283 | *"Buzz"* será en color amarillo y en el caso de imprimir *"FizzBuzz"* lo 284 | hará de color cían. 285 | 286 | > (No es necesario que pongas esos colores si no son de 287 | > tu agrado, en la [guía oficial](https://github.com/mackwic/colored#features) 288 | > del crate están listados todos los colores y estilos disponibles, anímate a 289 | > experimentar un poco). 290 | 291 | Veamos el código utilizando colores de Future Lab :D 292 | 293 | ```rust,ignore 294 | {{#include ../code/rust/colored-fizzbuzz.rs}} 295 | ``` 296 | 297 | Aun más elementos nuevos, vamos a explicarlos parte por parte: 298 | 299 | La declaración `extern crate` le especifica a Rust que nuestro programa 300 | depende de un biblioteca externa a nuestro proyecto, acercándola a 301 | nuestro alcance. 302 | 303 | ```rust,ignore 304 | {{#include ../code/rust/colored-fizzbuzz.rs:1}} 305 | ``` 306 | 307 | La declaración `use` crea enlaces locales a funciones o métodos remotos, 308 | se utiliza para simplificar el uso de localización de archivos. 309 | 310 | ```rust,ignore 311 | {{#include ../code/rust/colored-fizzbuzz.rs:3}} 312 | ``` 313 | 314 | Las siguientes líneas son sencillas de explicar: 315 | 316 | ```rust,ignore 317 | {{#include ../code/rust/colored-fizzbuzz.rs:8:11}} 318 | ``` 319 | 320 | Nuestro macro `println!` ha cambiado, en este caso el crate `colored` 321 | solo funciona con cadenas de caracteres, por lo que necesitamos 322 | colocar algo llamado *"placeholder"* que en resumen es un espacio 323 | donde se colocará un elemento más tarde, tenemos que separar con una 324 | coma los argumentos, en ese caso el segundo argumento será nuestra 325 | cadena, en este caso *"Fizz"*, *"Buzz"*, y *"FizzBuzz"*, solo resta 326 | agregar la función correspondiente. `colored` retorna cadenas en todas 327 | sus funciones por lo que no habrá problema si pasamos las funciones 328 | seguidas de un punto en este caso. 329 | 330 | La impresión del programa debería verse de esta manera en una 331 | ejecución normal: 332 | 333 | ![Salida De Colores](../images/colored-rust.png) 334 | 335 | Se ve genial ¿no?, puedes probar a hacer diferentes combinaciones, por ejemplo 336 | al imprimir "FizzBuzz" hacer que cada carácter tenga un color distinto: 337 | 338 | ![Salida De Colores](../images/colored-rust2.png) 339 | 340 | ¡Genial! Nuestro programa ahora imprime las cosas de una manera 341 | más *"elegante"*. Pero podemos notar un problema en las imágenes, 342 | los números evaluados son muy altos, no deberíamos de cargar al 343 | sistema con esa clase de operaciones. 344 | 345 | Podríamos colocar un límite superior en el ciclo `for` en nuestro 346 | código, pero, si bien es una buena solución la verdad sea dicha, tenemos 347 | planeado enseñarte algo que causa muchos problemas con los principiantes 348 | en el lenguaje de programación Rust. 349 | 350 | ## Operaciones de entrada 351 | 352 | Entre los usuarios Novel, pedir entrada de datos al usuario es un tema 353 | común, pues no existe una manera sencilla de hacerlo como en otros 354 | lenguajes como C, Python o Ruby. 355 | 356 | Esto tiene una razón sencilla, una entrada errónea del usuario puede 357 | causar comportamientos inesperados en los programas que podamos crear, 358 | puede parecer algo tedioso al inicio y es algo que se ha estado trabajando 359 | desde las versiones mas nuevas de Rust, aun así, las comparaciones entre 360 | Rust y otros lenguajes como Python y Ruby, carecen de sentido, pues 361 | cumplen roles diferentes. 362 | 363 | Vamos a pedir al usuario ingresar un número entero, el cual servirá como límite 364 | superior de nuestro ciclo `for`, con ello el usuario tendrá el control sobre 365 | las iteraciones de nuestro programa FizzBuzz. 366 | 367 | > En este caso, si el usuario ingresa cualquier cosa que no sea un número 368 | > entero se interpretará como un error irrecuperable y el programa se cerrará 369 | > inmediatamente. 370 | 371 | Primero necesitamos importar las bibliotecas necesarias para que el 372 | proyecto funcione, tendremos que crear una manera de pedir entrada al 373 | usuario y finalmente comprobar que nuestro programa funcione. 374 | 375 | El código completo debería verse de la siguiente manera: 376 | 377 | ```rust,ignore 378 | {{#include ../code/rust/finished-fizzbuzz.rs}} 379 | ``` 380 | 381 | De nuevo hay muchas cosas nuevas en este código, cosa que nos beneficiará 382 | pues los temas posteriores serán mas sencillos de digerir una vez 383 | comprendamos como funcionan con este tipo de ejemplos. 384 | 385 | Nuestro primer paso es *"importar las bibliotecas necesarias"*. 386 | 387 | ```rust,ignore 388 | {{#include ../code/rust/finished-fizzbuzz.rs:4}} 389 | //-- Mas código 390 | ``` 391 | Rust viene preparado con toda clase de cosas en su biblioteca estándar, 392 | sin embargo, si tuviésemos que importar cada cosa que utilizamos en 393 | nuestro código al final tendríamos un desastre. Al mismo tiempo, importar 394 | toneladas de bibliotecas a nuestro programa para dejar un gran porcentaje 395 | de éstas sin usar tampoco es algo bueno, por lo que un balance es 396 | necesario. Por lo que necesitaremos cargar las funciones de entrada y 397 | salida de la biblioteca estándar. 398 | 399 | Una vez tengamos las bibliotecas necesarias procederemos a pedir 400 | una entrada al usuario: 401 | 402 | ```rust,ignore 403 | //-- Recorte 404 | {{#include ../code/rust/finished-fizzbuzz.rs:7:9}} 405 | //-- Recorte 406 | ``` 407 | 408 | Primero necesitamos un lugar donde almacenar la entrada del usuario: 409 | 410 | ```rust,ignore 411 | {{#include ../code/rust/finished-fizzbuzz.rs:7}} 412 | ``` 413 | 414 | La declaración de variables se realiza con la palabra reservada 415 | `let` en Rust, cubriremos eso mas tarde, por ahora todo lo que tienes 416 | que saber es que con esta línea Rust está reservando una variable 417 | mutable (`mut`) llamada `entrada` (Si vienes de un lenguaje como Java 418 | podrás notar que es un método similar al de un `Scanner`, solo que con 419 | el estilo de Rust). 420 | 421 | Al igual que en otros lenguajes el operador `=` se utiliza para realizar 422 | una asignación, en el caso de nuestra línea de código estamos asignando 423 | el valor retornado por una función `String::new`, en este caso el valor 424 | que regresa la función es una nueva cadena. 425 | 426 | Similar a C++, Rust utiliza una sintáxis de 4 puntos para las funciones 427 | asociadas, por eso al llamar `::new()` estamos indicándole a Rust que 428 | `new` es una función asociada que retornará un `String`. 429 | 430 | En resumen la línea: 431 | ```rust,ignore 432 | {{#include ../code/rust/finished-fizzbuzz.rs:7}} 433 | ``` 434 | 435 | Crea una nueva variable con una instancia vacía de un `String`. 436 | 437 | Ahora necesitamos indicar a nuestro usuario sus instrucciones, este 438 | es un paso importante puesto que tenemos que ser claros, como nuestros 439 | usuarios son inteligentes, asumiremos que saben lo que significa 440 | *iteraciones* y procederemos a imprimir un mensaje en la pantalla. 441 | 442 | ```rust,ignore 443 | {{#include ../code/rust/finished-fizzbuzz.rs:8}} 444 | ``` 445 | 446 | Ahora necesitamos hacer algo para que el usuario ingrese el número y 447 | procesarlo para que se almacene en nuestra variable `entrada`: 448 | 449 | ```rust,ignore 450 | {{#include ../code/rust/finished-fizzbuzz.rs:9}} 451 | ``` 452 | 453 | Como al inicio del programa utilizamos la línea `use std::io;` ahora 454 | tenemos las funciones y métodos de entrada de texto necesarios para 455 | trabajar, al llamar a la función `stdin` esta retornará una instancia de 456 | `std::io::Stdin`, lo que nos permitirá manejar la entrada estándar desde 457 | la terminal. 458 | 459 | La siguiente parte del código es `.read_line(&mut entrada)`, con ello 460 | llamamos a la función `.read_line` y el argumento le indica a la función 461 | que deberá guardar la entrada del usuario en una referencia para usarla 462 | mas tarde. 463 | 464 | La última parte es la función `.unwrap()`, con la cual compararemos la 465 | entrada del resultado. Como indicamos al inicio de este capítulo, 466 | asumiremos que los errores son irrecuperables y `unwrap()` nos ayudará 467 | con ello, al llamar a ésta función estamos indicándole a Rust lo 468 | siguiente: *"Si bien esto puede o no tener un valor, yo afirmo que lo* 469 | *tiene. En caso contrario, el programa fallará, no quiero un error recuperable"*. 470 | 471 | ¡Listo!, con esto podemos pedir al usuario que ingrese *"algo"*, 472 | pero no nos basta con que ingrese *"algo"*, necesitamos que el 473 | usuario ingrese un número y cerrar el programa si ingresa cualquier 474 | cosa que no sea considerada un número: 475 | 476 | ```rust,ignore 477 | {{#include ../code/rust/finished-fizzbuzz.rs:11}} 478 | ``` 479 | 480 | A estas alturas ya sabemos lo que hace `let`, solo como recordatorio, estamos 481 | declarando una variable nueva, llamada `iter` (por *iteraciones*), pero hay 482 | algo nuevo aquí, específicamente `: i32`. ¿Qué es esto? Simple, estamos haciendo 483 | algo llamado *"tipeado"*, en este caso estamos indicando que nuestra variable 484 | `iter` será tratada como un *"entero de 32 bits"* (No necesitamos entrar a 485 | detalle en esto, pues lo cubriremos en capítulos posteriores), después volvemos 486 | a utilizar el operador de asignación pues necesitamos que nuestra variable 487 | tenga un valor, en este caso la asignación consta de tres partes: 488 | 489 | * `trim()`: Esta función eliminará el salto de línea que el usuario ingresa al 490 | final de la función stdin, sin ésta función no podremos procesar el salto de 491 | línea y `unwrap()` lo detectará como un error. 492 | 493 | * `parse()`: Aquí haremos algo llamado *parsing* o conversión de tipos. Como 494 | podemos recordar, lo que ingresó nuestro usuario hasta ahora es una cadena, así 495 | esté conformada por números Rust por el momento piensa que es una cadena de 496 | caracteres, con esta función estamos convirtiendo esa cadena al tipo de la 497 | variable que se le está asignando, en este caso, convertimos una cadena a un 498 | entero de 32 bits. 499 | 500 | * `unwrap()` ya lo hemos cubierto, pero se asegurará de que la conversión 501 | resultante devuelva un entero de 32 bits, en caso contrario retornará un error, 502 | haciendo que el programa detenga su ejecución. 503 | 504 | Bien, ya solo nos falta asignar el número ingresado por el usuario a nuestro 505 | ciclo `for` para completar nuestro programa. 506 | 507 | Si prestaste atención notarás que el ciclo for tiene un pequeño cambio, 508 | vamos a verlo: 509 | 510 | ```rust,ignore 511 | {{#include ../code/rust/finished-fizzbuzz.rs:13}} 512 | ``` 513 | 514 | ¡Hemos cambiado la estructura de nuestro ciclo! 515 | No es nada de que alarmarse, hemos realizado el cambio para tomar ventaja de 516 | la edición 2018 de Rust la cual nos permite utilizar ciclos inclusivos, si 517 | recordamos las reglas de los ciclos for escritas anteriormente podremos recordar 518 | lo siguiente: 519 | 520 | > "[...] por lo tanto nuestro ciclo 521 | > `for` imprimirá los valores del `0` al `4`, no hasta el número `5`." 522 | 523 | Al utilizar la notación `..=` el rango será inclusivo por lo que el ciclo 524 | se repetirá el número de veces indicado, con esto evitamos realizar una 525 | operación extra sobre la entrada del usuario. 526 | 527 | Una vez realizadas las correcciones ya podemos ejecutar nuestro programa. 528 | 529 | ¡Genial! Ahora ya sabes como realizar un programa FizzBuzz en Rust, es probable 530 | que tengas muchas preguntas en este momento ¿Por qué las variables mutan? ¿Qué 531 | es un ciclo? ¿Cuantos tipos de dato existen? ¿Cuales son los principios de Rust? 532 | 533 | Bien, esta y tus preguntas las resolveremos en el siguiente capítulo del libro 534 | en el cual trataremos conceptos básicos de programación, si deseas el código 535 | fuente del programa lo puedes conseguir en el siguiente 536 | [enlace](https://github.com/futurelabmx/rusty-lab/blob/master/src/code/rust/finished-fizzbuzz.rs). 537 | -------------------------------------------------------------------------------- /src/images/rocket/unsafe.svg: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 7 | 8 | 9 | 11 | 12 | 13 | 15 | 17 | 130 | 131 | 132 | 133 | 134 | 135 | 136 | 138 | 140 | 142 | 144 | 146 | 148 | 150 | 152 | 154 | 156 | 158 | 160 | 162 | 164 | 166 | 168 | 170 | 172 | 174 | 176 | 179 | 183 | 185 | 199 | 208 | 213 | 215 | 217 | 219 | 222 | 224 | 230 | 234 | 237 | 241 | 246 | 253 | 255 | 257 | 259 | 261 | 263 | 268 | 271 | 273 | 277 | 279 | 284 | 287 | 290 | 291 | 292 | --------------------------------------------------------------------------------