tutorial.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Tutorial Rust\n",
    "\n",
    "Tutorial realizado para la asignatura lenguages de programación 2019-2 de la Universidad Nacional de Colombia dictada por el Profesor Felipe Restrepo, dentro de este tutorial se cubrirán los aspectos básicos del lenguaje Rust y luego se enfocará al uso de este lenguaje dentro del paradigma de programación concurrente\n",
    "\n",
    "   ## Realizado por :\n",
    "   * Juan Sebastian Chaves Ramirez\n",
    "   * Jimmy Alexander Pulido Arias\n",
    "   * Laura Beatriz Santos Guerrero\n",
    "   "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Reseña\n",
    "Rust es un lenguaje de programación de sistemas de paradigmas múltiples centrado en la seguridad, especialmente la concurrencia segura.Rust es sintácticamente similar a C ++, pero está diseñado para proporcionar una mejor seguridad de la memoria mientras se mantiene un alto rendimiento.\n",
    "\n",
    "Rust fue diseñado originalmente por Graydon Hoare en Mozilla Research, con contribuciones de Dave Herman, Brendan Eich y otros. Los diseñadores refinaron el lenguaje mientras escribían el diseño Servo o el motor del navegador, y el compilador Rust. El compilador es un software gratuito y de código abierto con doble licencia bajo la Licencia MIT y la Licencia Apache 2.0. [wikipedia].\n",
    "\n",
    "[wikipedia]: https://en.wikipedia.org/wiki/Rust_(programming_language)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Variables y mutabilidad \n",
    "\n",
    "Por defecto las variables en Rust son **inmutables**. Este es uno de los muchos codazos que brinda Rust para escribir código en una manera que aproveche la seguridad y facilidad de hacer concurrencia que ofrece Rust.\n",
    "\n",
    "Cuando una variable es inmutable, una vez que un valor está vinculado a un nombre, no puede cambiar ese valor. Para ilustrar esto, veremos un ejemplo: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "ename": "Error",
     "evalue": "cannot assign twice to immutable variable `x`",
     "output_type": "error",
     "traceback": [
      "let x = 5;",
      "\u001b[91m    ^\u001b[0m \u001b[94mfirst assignment to `x`\u001b[0m",
      "x = 6;",
      "\u001b[91m^^^^^\u001b[0m \u001b[94mcannot assign twice to immutable variable\u001b[0m",
      "cannot assign twice to immutable variable `x`"
     ]
    }
   ],
   "source": [
    "let x = 5;\n",
    "format!(\"El valor de  x es: {}\", x);\n",
    "x = 6;\n",
    "eprintln!(\"El valor de  x es: {}\", x);\n",
    "\n",
    "\n",
    "// si se cambia la primera línea por let mut x = 5; compilará correctamente\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El mensaje de error indica que la causa del error es que no puede asignar dos veces a la variable inmutable x, porque trató de asignar un segundo valor a la variable inmutable x."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Los enlaces variables son inmutables por defecto, pero esto se puede anular utilizando el modificador **mut.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Antes de mutacion: 2\n",
      "Despues de mutation: 3\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fn main() {\n",
    "    let _asignacion_immutable = 1;\n",
    "    let mut asignacion_mutable = 2;\n",
    "\n",
    "    println!(\"Antes de mutacion: {}\", asignacion_mutable);\n",
    "\n",
    "    // Ok\n",
    "    asignacion_mutable += 1;\n",
    "\n",
    "    println!(\"Despues de mutacion: {}\", asignacion_mutable);\n",
    "\n",
    "    // Error!\n",
    "    _immutable_binding += 1;\n",
    "    // Comentar ^ para arreglar\n",
    "}\n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## *Shadowing*\n",
    "\n",
    "Es la capacidad de rust para redelarar variables con el mismo nombre, veamoslo con un ejemplo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Valor de strUniversidad nacional\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<table><tr><th>Variable</th><th>Type</th></tr><tr><td>str</td><td>&str</td><tr></table>"
      ],
      "text/plain": [
       "str: &str\n"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Valor de str Rust tutorial\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<table><tr><th>Variable</th><th>Type</th></tr><tr><td>str</td><td>&str</td><tr></table>"
      ],
      "text/plain": [
       "str: &str\n"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Valor de str 26\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<table><tr><th>Variable</th><th>Type</th></tr><tr><td>str</td><td>usize</td><tr></table>"
      ],
      "text/plain": [
       "str: usize\n"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let str = \"Universidad nacional\";\n",
    "println!(\"Valor de str {}\", str);\n",
    ":vars\n",
    "\n",
    "// cambiar el valor de una variable inmutable\n",
    "let str = \"Valor de str Rust tutorial\";\n",
    "println!(\"{}\", str);\n",
    ":vars\n",
    "\n",
    "// cambiar el valor y el tipo de una variable inmutable\n",
    "\n",
    "let str = str.len();\n",
    "println!(\"Valor de str {}\", str);\n",
    ":vars"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Pertenencia o *Ownership*\n",
    "\n",
    "El concepto de ownership se refiere a la capacidad de rust para que solo una variable sea la encargada de administrar un espacio de memoria del heap del proceso. Dentro de la ejecución de un proceso existen dos tipos de memoria, stack y heap. El stack se refiere a memoria constante y variables de tipo primitivo que pueden ser accedidas facilmente, mientras que en el heap se almacena memoria dinámica y variables no primitivas como structuras y colecciones.\n",
    "\n",
    "Veamoslo con unps ejemplos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En este ejemplo la pertenencia es otorgada de str1 a str2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "ename": "Error",
     "evalue": "no method named `push_str` found for type `&str` in the current scope",
     "output_type": "error",
     "traceback": [
      "s.push_str(\", world!\"); ",
      "\u001b[91m  ^^^^^^^^\u001b[0m \u001b[94mmethod not found in `&str`\u001b[0m",
      "no method named `push_str` found for type `&str` in the current scope"
     ]
    }
   ],
   "source": [
    "\n",
    "let mut s = String::from(\"hello\");\n",
    "//let mut s = \"hello\";\n",
    "s.push_str(\", world!\"); // push_str() concatena el literal al final\n",
    "// si no se declara de usando String::from no se puede concanenar \n",
    "println!(\"{}\", s); \n",
    "\n",
    "let str1 = String::from(\"una cadenita\");\n",
    "\n",
    "let str2 = str1;\n",
    "\n",
    "\n",
    "// al tratar de imprimir str1 sale un error debido a que la pertenencia fue otorgada a str2\n",
    "println!(\"{} \", str2)\n",
    "\n",
    "// cambiar str1 por str2 ^"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En el main nos damos cuenta que el valor retornado por gives_ownership se almacena en s1 y pasa a ser parte del alcance del main. Luego, genera una cadena s2. s3 sera el valor de retorno de la funcion takes_and_gives_back (se ingresa s2 como parametro)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fn main() {\n",
    "    let s1 = gives_ownership();         // gives_ownership moves its return\n",
    "                                        // value into s1\n",
    "\n",
    "    let s2 = String::from(\"hello\");     // s2 comes into scope\n",
    "\n",
    "    let s3 = takes_and_gives_back(s2);  // s2 is moved into\n",
    "                                        // takes_and_gives_back, which also\n",
    "                                        // moves its return value into s3\n",
    "} // Here, s3 goes out of scope and is dropped. s2 goes out of scope but was\n",
    "  // moved, so nothing happens. s1 goes out of scope and is dropped.\n",
    "\n",
    "fn gives_ownership() -> String {             // gives_ownership will move its\n",
    "                                             // return value into the function\n",
    "                                             // that calls it\n",
    "\n",
    "    let some_string = String::from(\"hello\"); // some_string comes into scope\n",
    "\n",
    "    some_string                              // some_string is returned and\n",
    "                                             // moves out to the calling\n",
    "                                             // function\n",
    "}\n",
    "\n",
    "// takes_and_gives_back will take a String and return one\n",
    "fn takes_and_gives_back(a_string: String) -> String { // a_string comes into\n",
    "                                                      // scope\n",
    "\n",
    "    a_string  // a_string is returned and moves out to the calling function\n",
    "}\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Referencia y *Borrowing*\n",
    "\n",
    "Para entender las Referencias y el *Borrowing* es bueno verlo con un ejemplo: \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fn main() {\n",
    "    let s1 = String::from(\"hello\");\n",
    "\n",
    "    let len = calculate_length(&s1);\n",
    "\n",
    "    println!(\"The length of '{}' is {}.\", s1, len);\n",
    "}\n",
    "\n",
    "fn calculate_length(s: &String) -> usize {\n",
    "    s.len()\n",
    "} // Here, s goes out of scope. But because it does not have ownership of what\n",
    "  // it refers to, nothing happens."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Los ampersands son referencias y permiten referirse a algún valor sin tomar *ownership* de él. \n",
    "\n",
    "![image.png](attachment:image.png)/y\n",
    "\n",
    "\n",
    "La sintaxis *&s1* nos permite crear una referencia que se refiere al valor de **s1** pero que no lo posee. Como no lo posee, el valor al que apunta no se descartará cuando la referencia salga del alcance (*scope*)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Qué pasa si traramos de **modificar** algo que pedimos prestado? "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "ename": "Error",
     "evalue": "cannot borrow `*some_string` as mutable, as it is behind a `&` reference",
     "output_type": "error",
     "traceback": [
      "    some_string.push_str(\", world\");",
      "\u001b[91m    ^^^^^^^^^^^\u001b[0m \u001b[94m`some_string` is a `&` reference, so the data it refers to cannot be borrowed as mutable\u001b[0m",
      "cannot borrow `*some_string` as mutable, as it is behind a `&` reference"
     ]
    }
   ],
   "source": [
    "fn main() {\n",
    "    let s = String::from(\"hello\");\n",
    "\n",
    "    change(&s);\n",
    "}\n",
    "\n",
    "fn change(some_string: &String) {\n",
    "    some_string.push_str(\", world\");\n",
    "}\n",
    "\n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nos aparecerá un error como:  *some_string` is a `&` reference, so the data it refers to cannot be borrowed as mutable`*. \n",
    "\n",
    "> Hay que recordar que por defecto las variables son inmutables, al igual que las referencias. No podemos modificar algo a lo que tenemos referencia.\n",
    "\n",
    "\n",
    "## Referencias mutables \n",
    "\n",
    "Podemos corregir el error en el código del Listado 4-6 con solo un pequeño ajuste:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fn main() {\n",
    "    let mut s = String::from(\"hello\");\n",
    "\n",
    "    change(&mut s);\n",
    "}\n",
    "\n",
    "fn change(some_string: &mut String) {\n",
    "    some_string.push_str(\", world\");\n",
    "}\n",
    "\n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Primero, tuvimos que **cambiar s** para ser *mut*. Luego tuvimos que crear una referencia mutable con *&mut s* y aceptar una referencia mutable con *some_string: & mut String*.\n",
    "\n",
    "> Pero las referencias mutables tienen una gran restricción: solo puede tener una referencia mutable a un dato en particular en un ámbito particular. Este código fallará\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "ename": "Error",
     "evalue": "`s` does not live long enough",
     "output_type": "error",
     "traceback": [
      "let r1 = &mut s;",
      "\u001b[91m         ^^^^^^\u001b[0m \u001b[94mborrowed value does not live long enough\u001b[0m",
      "`s` does not live long enough"
     ]
    },
    {
     "ename": "Error",
     "evalue": "cannot borrow `s` as mutable more than once at a time",
     "output_type": "error",
     "traceback": [
      "let r1 = &mut s;",
      "\u001b[91m         ^^^^^^\u001b[0m \u001b[94mfirst mutable borrow occurs here\u001b[0m",
      "let r2 = &mut s;",
      "\u001b[91m         ^^^^^^\u001b[0m \u001b[94msecond mutable borrow occurs here\u001b[0m",
      "cannot borrow `s` as mutable more than once at a time"
     ]
    },
    {
     "ename": "Error",
     "evalue": "cannot move out of `s` because it is borrowed",
     "output_type": "error",
     "traceback": [
      "let r1 = &mut s;",
      "\u001b[91m         ^^^^^^\u001b[0m \u001b[94mborrow of `s` occurs here\u001b[0m",
      "cannot move out of `s` because it is borrowed"
     ]
    }
   ],
   "source": [
    "let mut s = String::from(\"hello\");\n",
    "\n",
    "let r1 = &mut s;\n",
    "let r2 = &mut s;\n",
    "\n",
    "println!(\"{}, {}\", r1, r2);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Ejemplo de mutabilidad y Borrowing "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I immutably borrowed Gödel, Escher, Bach - 1979 edition\n",
      "I immutably borrowed Gödel, Escher, Bach - 1979 edition\n",
      "I mutably borrowed Gödel, Escher, Bach - 2979 edition\n",
      "h 2979\n"
     ]
    }
   ],
   "source": [
    "struct Book {\n",
    "    // `&'static str` es una referencia a un string alocato en memoia de solo relctura \n",
    "    author: &'static str,\n",
    "    title: &'static str,\n",
    "    year: u32,\n",
    "}\n",
    "\n",
    "//  Funcion toma como referencia un Book\n",
    "fn borrow_book(book: &Book) {\n",
    "    println!(\"I immutably borrowed {} - {} edition\", book.title, book.year);\n",
    "}\n",
    "\n",
    "// Funcion toma como referencia un Book mutable y cambia incrementa el year + 1\n",
    "fn new_edition(book: &mut Book) {\n",
    "    book.year = book.year + 1000 ;\n",
    "    println!(\"I mutably borrowed {} - {} edition\", book.title, book.year);\n",
    "}\n",
    "\n",
    "// Crea un libro inmutable `immutabook`\n",
    "let immutabook = Book {\n",
    "    // string literals have type `&'static str`\n",
    "    author: \"Douglas Hofstadter\",\n",
    "    title: \"Gödel, Escher, Bach\",\n",
    "    year: 1979,\n",
    "};\n",
    "    \n",
    "// Immutably borrow an immutable object\n",
    "borrow_book(&immutabook);\n",
    "\n",
    "// Create a mutable copy of `immutabook` and call it `mutabook`\n",
    "let mut mutabook = immutabook;\n",
    "\n",
    "// Immutably borrow a mutable object\n",
    "borrow_book(&mutabook);\n",
    "    \n",
    "// Borrow a mutable object as mutable\n",
    "new_edition(&mut mutabook);\n",
    "\n",
    "//new_edition(&mut immutabook);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# *Closure*\n",
    "\n",
    "Una closure es una función anónima que puede ser guardada en una variable y por ende ser enviada como parametro en una función\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "llamado de add_one(x)  = 6 \n",
      "resultado del closure llamado dentro de una funcion 33\n"
     ]
    }
   ],
   "source": [
    "fn test() {\n",
    "    \n",
    "\n",
    "    let add_one = |num| {\n",
    "\n",
    "        // El valor que se quiere retornar se coloca sin punto y coma al final\n",
    "        num + 1\n",
    "    };\n",
    "    \n",
    "    let mut x = 5;\n",
    "    println!(\"llamado de add_one(x)  = {} \", add_one(x));\n",
    "    \n",
    "    fn clossure_como_argumento<F>(some_closure: F, x: i32) -> i32\n",
    "    where F: Fn(i32) -> i32 {\n",
    "\n",
    "        some_closure(x)\n",
    "    }\n",
    "    \n",
    "    let val = clossure_como_argumento(add_one, 32);\n",
    "    \n",
    "    println! (\"resultado del closure llamado dentro de una funcion {}\", val);\n",
    "}\n",
    "\n",
    "test();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##  HILOS (THREADS): \n",
    "Los hilos (Threads) se usan para correr partes de código independientes simultáneamente.  Esto puede mejorar el rendimiento del programa al realizar múltiples tareas al mismo tiempo.\n",
    "Para crear un hilo se llama la función **thread::spawn** que contenga un closure.\n",
    "En el siguiente ejemplo, se imprime texto del hilo principal, y otro del nuevo hilo. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hi number 1 from the main thread!\n",
      "hi number 1 from the spawned thread!\n",
      "hi number 2 from the main thread!\n",
      "hi number 2 from the spawned thread!\n",
      "hi number 3 from the main thread!\n",
      "hi number 3 from the spawned thread!\n",
      "hi number 4 from the main thread!\n",
      "hi number 4 from the spawned thread!\n",
      "hi number 5 from the spawned thread!\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "use std::thread;\n",
    "use std::time::Duration;\n",
    "\n",
    "fn main() {\n",
    "    thread::spawn(|| {\n",
    "        for i in 1..10 {\n",
    "            println!(\"hi number {} from the spawned thread!\", i);\n",
    "            thread::sleep(Duration::from_millis(1));\n",
    "        }\n",
    "    });\n",
    "\n",
    "    for i in 1..5 {\n",
    "        println!(\"hi number {} from the main thread!\", i);\n",
    "        thread::sleep(Duration::from_millis(1));\n",
    "    }\n",
    "}\n",
    "\n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nos damos cuenta que el hilo nuevo se detendrá cuando el hilo principal termine, halla o no terminado su función.  De hecho, este código no nos puede garantizar ni siquiera que los hilos hayan llegado a correr en algún momento. \n",
    "La función thread::spawn retorna un variable tipo JoingHandle, a la cual si le aplicamos la función join, esperará a que los hilos hayan terminado.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hi number 6 from the spawned thread!\n",
      "hi number 7 from the spawned thread!\n",
      "hi number 8 from the spawned thread!\n",
      "hi number 9 from the spawned thread!\n",
      "hi number 1 from the main thread!\n",
      "hi number 1 from the spawned thread!\n",
      "hi number 2 from the main thread!\n",
      "hi number 2 from the spawned thread!\n",
      "hi number 3 from the main thread!\n",
      "hi number 3 from the spawned thread!\n",
      "hi number 4 from the main thread!\n",
      "hi number 4 from the spawned thread!\n",
      "hi number 5 from the spawned thread!\n",
      "hi number 6 from the spawned thread!\n",
      "hi number 7 from the spawned thread!\n",
      "hi number 8 from the spawned thread!\n",
      "hi number 9 from the spawned thread!\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "use std::thread;\n",
    "use std::time::Duration;\n",
    "\n",
    "fn main() {\n",
    "    let handle = thread::spawn(|| {\n",
    "        for i in 1..10 {\n",
    "            println!(\"hi number {} from the spawned thread!\", i);\n",
    "            thread::sleep(Duration::from_millis(1));\n",
    "        }\n",
    "    });\n",
    "\n",
    "    for i in 1..5 {\n",
    "        println!(\"hi number {} from the main thread!\", i);\n",
    "        thread::sleep(Duration::from_millis(1));\n",
    "    }\n",
    "\n",
    "    handle.join().unwrap();\n",
    "} \n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Asi se encargará de bloquear (evitar que trabaje o que termine) el hilo que corre actualmente hasta que el hilo representado por el handle termine. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En el caso que el *join* se colocar justo antes del loop del hilo principal, se produciría una salida como:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hi number 1 from the spawned thread!\n",
      "hi number 2 from the spawned thread!\n",
      "hi number 3 from the spawned thread!\n",
      "hi number 4 from the spawned thread!\n",
      "hi number 5 from the spawned thread!\n",
      "hi number 6 from the spawned thread!\n",
      "hi number 7 from the spawned thread!\n",
      "hi number 8 from the spawned thread!\n",
      "hi number 9 from the spawned thread!\n",
      "hi number 1 from the main thread!\n",
      "hi number 2 from the main thread!\n",
      "hi number 3 from the main thread!\n",
      "hi number 4 from the main thread!\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "use std::thread;\n",
    "use std::time::Duration;\n",
    "\n",
    "fn main() {\n",
    "    let handle = thread::spawn(|| {\n",
    "        for i in 1..10 {\n",
    "            println!(\"hi number {} from the spawned thread!\", i);\n",
    "            thread::sleep(Duration::from_millis(1));\n",
    "        }\n",
    "    });\n",
    "\n",
    "    handle.join().unwrap();\n",
    "\n",
    "    for i in 1..5 {\n",
    "        println!(\"hi number {} from the main thread!\", i);\n",
    "        thread::sleep(Duration::from_millis(1));\n",
    "    }\n",
    "}\n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Se puede también utilizar la función **move** para tomar posesión *(ownership)* de los valores que se están usando el el closure. Se evita así que la referencia deje de ser valida en la ejecución de alguno de los hilos. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "ename": "Error",
     "evalue": "closure may outlive the current function, but it borrows `v`, which is owned by the current function",
     "output_type": "error",
     "traceback": [
      "        println!(\"Here's a vector: {:?}\", v);",
      "\u001b[91m                                          ^\u001b[0m \u001b[94m`v` is borrowed here\u001b[0m",
      "    let handle = thread::spawn(|| {",
      "\u001b[91m                               ^^\u001b[0m \u001b[94mmay outlive borrowed value `v`\u001b[0m",
      "closure may outlive the current function, but it borrows `v`, which is owned by the current function"
     ]
    }
   ],
   "source": [
    "use std::thread;\n",
    "\n",
    "fn main() {\n",
    "    let v = vec![1, 2, 3];\n",
    "\n",
    "    let handle = thread::spawn(|| {\n",
    "        println!(\"Here's a vector: {:?}\", v);\n",
    "    });\n",
    "\n",
    "    handle.join().unwrap();\n",
    "}\n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Y corregido: \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Here's a vector: [1, 2, 3]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "use std::thread;\n",
    "\n",
    "fn main() {\n",
    "    let v = vec![1, 2, 3];\n",
    "\n",
    "    let handle = thread::spawn(move || {\n",
    "        println!(\"Here's a vector: {:?}\", v);\n",
    "    });\n",
    "\n",
    "    handle.join().unwrap();\n",
    "}\n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## CANALES (CHANNELS): \n",
    "Los canales son un concepto que provee Rust para facilitar la comunicación entre hilos al permitir el intercambio de mensajes. \n",
    "Un canal se compone de *transmitter* (el que transmite) and *receiver* (el que receiver). La idea es enviar datos desde una parte del código y revisar en otra parte la llegada de los mensajes. \n",
    "La función **mpsc::channel** (multiple producer single consumer)permite que un canal tenga múltiples transmitter y un único receiver.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Got: hi\n"
     ]
    }
   ],
   "source": [
    "use std::thread;\n",
    "use std::sync::mpsc;\n",
    "\n",
    "let (tx, rx) = mpsc::channel();\n",
    "\n",
    "thread::spawn(move || {\n",
    "    let val = String::from(\"hi\");\n",
    "    tx.send(val).unwrap();\n",
    "    //println!(\"val is {}\", val);\n",
    "});\n",
    "\n",
    "let received = rx.recv().unwrap();\n",
    "println!(\"Got: {}\", received);\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Mediante la función send se envió por el canal un mensaje, recordemos que se ha movido el propietario de tx al closure mediante la función move, y ahora obtendremos de vuelta el mensaje mediante la función rcv().\n",
    "La función send retorna un valor tipo Result, de tal manera que advierta si un mensaje enviado no ha llegado a ningún destinatario al retornar Err. \n",
    "Vale la pena anotar que descomentar la líne de println que está dentro del closure generaría un error porque la pertenencia de la variable val ya no le pertenece al hilo. Esto permite seguridad y consistencia al código y evita error de manejo de mensajes una vez han sido enviados. \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# MUTEX (MUTUAL EXCLUSION / EXCLUSION MUTUA)\n",
    "Este recurso permite que únicamente un recurso tenga acceso a un mismo dato en un momento dado. Para tener acceso al dato, el recurso debe pedir permiso de acceso mediante el mutex’s lock (candado), que es la estructura que mantiene el registro sobre qué recurso tiene acceso exclusivo al dato. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "m = Mutex { data: 6 }\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "use std::sync::Mutex;\n",
    "\n",
    "\n",
    "    let m = Mutex::new(5);\n",
    "\n",
    "    {\n",
    "        let mut num = m.lock().unwrap();\n",
    "        *num = 6;\n",
    "    }\n",
    "\n",
    "    println!(\"m = {:?}\", m);\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Por defecto, al terminar con el alcance de una variable mutex, el candado asociado se va a abrir nuevamente, permitiendo que m sea utilizado nuevamente por println. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Ejemplo adivinar el numero"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hilo que ejecuta el juego"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "El numero secreto es: 32\n"
     ]
    }
   ],
   "source": [
    ":dep rand = \"0.3.14\"\n",
    "use std::sync::{Mutex, Arc};\n",
    "use rand::Rng;\n",
    "use std::cmp::Ordering;\n",
    "\n",
    "\n",
    "let counter = Arc::new(Mutex::new(0i32));\n",
    "std::thread::spawn({\n",
    "    let counter = Arc::clone(&counter);\n",
    "    \n",
    "    let secret_number = rand::thread_rng().gen_range(1, 101);\n",
    "\n",
    "        println!(\"El numero secreto es: {}\", secret_number);\n",
    "\n",
    "\n",
    "    move || {\n",
    "        *counter.lock().unwrap() = -1;\n",
    "        let mut last = -1;\n",
    "        loop {\n",
    "            \n",
    "            \n",
    "            let mut guess = *counter.lock().unwrap();\n",
    "            if guess != last {\n",
    "                println!(\"Numero ingresado: {}\", guess);\n",
    "                match guess.cmp(&secret_number) {\n",
    "                    Ordering::Less => println!(\"Muy pequeño!\"),\n",
    "                    Ordering::Greater => println!(\"Muy grande!\"),\n",
    "                    Ordering::Equal => {\n",
    "                        println!(\"Ganaste!\");\n",
    "                        break;\n",
    "                    },\n",
    "                }\n",
    "                last = guess;\n",
    "            }\n",
    "            \n",
    "        \n",
    "            std::thread::sleep(std::time::Duration::from_millis(100));\n",
    "        }\n",
    "        println!(\"Juego finalizado\");\n",
    "}});"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Celda para intenar adivinar"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "*counter.lock().unwrap() = 32;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Celda para revisar el valor ingresado"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Numero ingresado: 32\n",
      "Ganaste!\n",
      "Juego finalizado\n"
     ]
    }
   ],
   "source": [
    "*counter.lock().unwrap();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Ejemplo Fractales "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    ":dep threadpool = \"1.7.1\"\n",
    ":dep num = \"0.2.0\"\n",
    ":dep num_cpus = \"1.11.1\"\n",
    ":dep image = \"0.22.3\"\n",
    "\n",
    "extern crate threadpool;\n",
    "extern crate num;\n",
    "extern crate num_cpus;\n",
    "extern crate image;\n",
    "\n",
    "use std::error::Error;\n",
    "use std::sync::mpsc::{channel, RecvError};\n",
    "use threadpool::ThreadPool;\n",
    "use num::complex::Complex;\n",
    "use image::{ImageBuffer, Pixel, Rgb};\n",
    "\n",
    "fn wavelength_to_rgb(wavelength: u32) -> Rgb<u8> {\n",
    "     let wave = wavelength as f32;\n",
    "\n",
    "     let (r, g, b) = match wavelength {\n",
    "         380..=439 => ((440. - wave) / (440. - 380.), 0.0, 1.0),\n",
    "         440..=489 => (0.0, (wave - 440.) / (490. - 440.), 1.0),\n",
    "         490..=509 => (0.0, 1.0, (510. - wave) / (510. - 490.)),\n",
    "         510..=579 => ((wave - 510.) / (580. - 510.), 1.0, 0.0),\n",
    "         580..=644 => (1.0, (645. - wave) / (645. - 580.), 0.0),\n",
    "         645..=780 => (1.0, 0.0, 0.0),\n",
    "         _ => (0.0, 0.0, 0.0),\n",
    "     };\n",
    "\n",
    "     let factor = match wavelength {\n",
    "         380..=419 => 0.3 + 0.7 * (wave - 380.) / (420. - 380.),\n",
    "         701..=780 => 0.3 + 0.7 * (780. - wave) / (780. - 700.),\n",
    "         _ => 1.0,\n",
    "     };\n",
    "\n",
    "     let (r, g, b) = (normalize(r, factor), normalize(g, factor), normalize(b, factor));\n",
    "     Rgb::from_channels(r, g, b, 0)\n",
    " }\n",
    "\n",
    " // Maps Julia set distance estimation to intensity values  u32  unsigned \n",
    " fn julia(c: Complex<f32>, x: u32, y: u32, width: u32, height: u32, max_iter: u32) -> u32 {\n",
    "     let width = width as f32;\n",
    "     let height = height as f32;\n",
    "\n",
    "     let mut z = Complex {\n",
    "         // scale and translate the point to image coordinates\n",
    "         re: 3.0 * (x as f32 - 0.5 * width) / width,\n",
    "         im: 2.0 * (y as f32 - 0.5 * height) / height,\n",
    "     };\n",
    "\n",
    "     let mut i = 0;\n",
    "     for t in 0..max_iter {\n",
    "         if z.norm() >= 2.0 {\n",
    "             break;\n",
    "         }\n",
    "         z = z * z + c;\n",
    "         i = t;\n",
    "     }\n",
    "     i\n",
    " }\n",
    "\n",
    " // Normalizes color intensity values within RGB range\n",
    " fn normalize(color: f32, factor: f32) -> u8 {\n",
    "     ((color * factor).powf(0.8) * 255.) as u8\n",
    " }"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Una *extern crate declaration*  especifica una dependencia en *external crate.* La caja externa se vincula al ámbito de declaración como el identificador proporcionado en la declaración de caja externa. La cláusula as se puede usar para vincular la caja importada a un nombre diferente.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Ok(())"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fn main() -> Result<(), Box<dyn Error>> {\n",
    "    let (width, height) = (1920, 1080);\n",
    "    let mut img = ImageBuffer::new(width, height);\n",
    "    let iterations = 300;\n",
    "\n",
    "    let c = Complex::new(-0.8,  0.2);\n",
    "\n",
    "    let pool = ThreadPool::new(num_cpus::get());\n",
    "    let (tx, rx) = channel();\n",
    "\n",
    "    for y in 0..height {\n",
    "        let tx1 = tx.clone();\n",
    "        pool.execute(move || for x in 0..width/2 {\n",
    "                         let i = julia(c, x, y, width, height, iterations);\n",
    "                         let pixel = wavelength_to_rgb(380 + i * 400 / iterations);\n",
    "                         tx1.send((x, y, pixel)).expect(\"Could not send data!\");\n",
    "                     });\n",
    "        let tx2 = tx.clone();\n",
    "        pool.execute(move || for x in width/2..width {\n",
    "                         let i = julia(c, x, y, width, height, iterations);\n",
    "                         let pixel = wavelength_to_rgb(380 + i * 400 / iterations);\n",
    "                         tx2.send((x, y, pixel)).expect(\"Could not send data!\");\n",
    "                     });\n",
    "    }\n",
    "\n",
    "    for _ in 0..(width * height) {\n",
    "        let (x, y, pixel) = rx.recv()?;\n",
    "        img.put_pixel(x, y, pixel);\n",
    "    }\n",
    "    let _ = img.save(\"output.png\")?;\n",
    "    Ok(())\n",
    "}\n",
    "\n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# MUTEX (MUTUAL EXCLUSION / EXCLUSION MUTUA)\n",
    "\n",
    "Este recurso permite que únicamente un recurso tenga acceso a un mismo dato en un momento dado. Para tener acceso al dato, el recurso debe pedir permiso de acceso mediante el mutex’s lock (candado), que es la estructura que mantiene el registro sobre qué recurso tiene acceso exclusivo al dato. \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![output.png](output.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Rust",
   "language": "rust",
   "name": "rust"
  },
  "language_info": {
   "codemirror_mode": "rust",
   "file_extension": ".rs",
   "mimetype": "text/rust",
   "name": "Rust",
   "pygment_lexer": "rust",
   "version": ""
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}