Introduction à Rust.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "\n",
    "# Introduction à Rust\n",
    "\n",
    "[Pierre-Antoine Champin](http://champin.net/)\n",
    "\n",
    "http://github.com/pchampin/journees-rust-2022/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "fn main() {  \n",
    "    println!(\"hello world\");\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Gestionnaire de projet `cargo`\n",
    "\n",
    "L'outil `cargo` est un outil central pour le développement rust.\n",
    "\n",
    "Il sert notamment à :\n",
    "\n",
    "* créer un nouveau projet (`cargo new <dirname>`)\n",
    "* compiler un projet (`cargo build`)\n",
    "* exécuter un projet (`cargo run`) – en le compilant préalablement si nécessaire\n",
    "* exécuter les tests unitaires (`cargo test`)\n",
    "* générer la documentation (`cargo doc`)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Anatomie d'un projet créé par cargo\n",
    "\n",
    "```\n",
    "myproject\n",
    " \\_ .git\n",
    " \\_ .gitignore\n",
    " \\_ Cargo.toml\n",
    " \\_ src\n",
    "     \\_ main.rs\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "```\n",
    "     \\_ ...\n",
    " \\_ tests\n",
    "     \\_ ...\n",
    " \\_ examples\n",
    "     \\_ ...\n",
    " \\_ target\n",
    "     \\_ ...\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Le fichier `Cargo.toml` initial:\n",
    "\n",
    "```toml\n",
    "[package]\n",
    "name = \"myproject\"\n",
    "version = \"0.1.0\"\n",
    "edition = \"2021\"\n",
    "\n",
    "# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html\n",
    "\n",
    "[dependencies]\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Gestion des dépendances\n",
    "\n",
    "Par défaut, `cargo` récuère les dépendances sur `https://crates.io/`,\n",
    "\n",
    "mais d'autres options sont possibles :\n",
    "\n",
    "- répertoire local,\n",
    "- dépôt git local ou distant,\n",
    "- registre alternatif."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Syntaxe"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Exemple, la fonction factorielle"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "fn fact(n: u64) -> u64 {\n",
    "    if n == 0 {\n",
    "        return 1;\n",
    "    } else {\n",
    "        return n*fact(n-1);\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2432902008176640000"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fact(20)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* `fn` désigne une fonction\n",
    "* `n: u64` désigne un paramètre, suivi de son type (entier non signé sur 64 bits)\n",
    "* `-> u64` indique le type de retour (facultatif si la fonction ne retourne rien)\n",
    "* pas de parenthèse autour de la condition du `if`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Version itérative"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "fn fact(n: u64) -> u64 {\n",
    "    let mut f: u64 = 1;\n",
    "    let mut i: u64 = 2;\n",
    "    while i <= n {\n",
    "        f *= i;\n",
    "        i += 1;\n",
    "    }\n",
    "    return f;\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "assert_eq!(fact(7), 5040); // test"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* `let` sert à déclarer une variable locale\n",
    "* `mut` indique que la variable est mutable (c.à.d. que sa valeur va changer au cours de sa vie)\n",
    "* pas de parenthèse autour de la condition du `while`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Version itérative plus idiomatique 🦀"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "fn fact(n: u64) -> u64 {\n",
    "    let mut f = 1;\n",
    "    let mut i = 2;\n",
    "    while i <= n {\n",
    "        f *= i;\n",
    "        i += 1;\n",
    "    }\n",
    "    f \n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "assert_eq!(fact(7), 5040); // test"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* 🦀 **inférence de type**: le compilateur est le plus souvent capable de deviner le type d'une variable locale ; dans ce cas, il n'est pas nécessaire de le préciser\n",
    "* il faut quand même préciser `mut` (pour éviter les erreurs)\n",
    "* 🦀 tout bloc de code (entre accolades) est une **expression** dont la valeur est la dernière expression du bloc (*sans* point-virgule)\n",
    "* une fonction qui atteint la fin de son bloc retourne la valeur de ce bloc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "// autre exemple de d'utilisation d'un bloc comme une expression\n",
    "let x = 18;\n",
    "let y = 12;\n",
    "let pgcd = {\n",
    "    // algorithme d'Euclide\n",
    "    let mut a = x;\n",
    "    let mut b = y;\n",
    "    while b > 0 {\n",
    "        let tmp = a;\n",
    "        a = b;\n",
    "        b = tmp % b;\n",
    "    }\n",
    "    a\n",
    "};"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pgcd"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Version récursive plus idiomatique 🦀"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "fn fact(n: u64) -> u64 {\n",
    "    if n == 0 {\n",
    "        1\n",
    "    } else {\n",
    "        n*fact(n-1)\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "assert_eq!(fact(7), 5040); // test"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* une clause `if` est une expression dont la valeur est celle du bloc « then » ou du bloc `else`\n",
    "* le retour de la fonction `fact` est donc ici la valeur du `if`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "// autre exemple de d'utilisation d'un bloc if comme une expression\n",
    "let x = -21;\n",
    "\n",
    "let a = if x>=0 {\n",
    "    x\n",
    "} else {\n",
    "    -2*x\n",
    "};"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "42"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Boucle `for`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "fn fact(n: u64) -> u64 {\n",
    "    let mut f = 1;\n",
    "    for i in 2..=n {\n",
    "        f *= i;\n",
    "    }\n",
    "    f\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "assert_eq!(fact(7), 5040); // test"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* la boucle `for` attend un **itérateur** et itère sur toutes ses valeurs\n",
    "* `i..=j` itère sur toutes les valeurs de l'intervalle $[i,j]$\n",
    "* `i..j` itère sur toutes les valeurs de l'intervalle $[i,j[$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Clause `match`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "fn fact(n: u64) -> u64 {\n",
    "    match n {\n",
    "        0 | 1 => 1,\n",
    "        2..=20 => n*fact(n-1),\n",
    "        _ => panic!(\"trop grand\"),\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* La clause `match` évalue la première « branche » (*leg*)\n",
    "  satisfaite par la valeur passée.\n",
    "* Le choix `_` est satisfait par n'importe quelle valeur.\n",
    "\n",
    "Important :\n",
    "* Toutes les branches doivent être des expressions du même type.\n",
    "* La clause match doit être **exhaustive** (les choix doivent couvrir toutes les valeurs possibles)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* Les branches de `match` peuvent contenir des blocs (puisque ce sont des expressions).\n",
    "* Les branches de `match` peuvent ne pas donner de valeur."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "fn il_m_aime(n: usize) {\n",
    "    match n {\n",
    "        0..=9 => {\n",
    "            println!(\"un peu\");\n",
    "        }\n",
    "        10..=99 => {\n",
    "            println!(\"beaucoup\");\n",
    "        }\n",
    "        _ => {\n",
    "            println!(\"passionnément\");\n",
    "        }\n",
    "        \n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "NB: la clause `match` est beaucoup plus puissante que ce que ces exemples montrent.\n",
    "On la retrouvera plus tard..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Types"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Types primitifs\n",
    "\n",
    "* Entiers (`i8`, `i16`, `i32`, `i64`, `i128`, `isize`) — e.g. `42`, `-1`\n",
    "    \n",
    "* Entiers non signés (`u8`, `u16`, `u32`, `u64`, `u128`, `usize`) — e.g. `42`, `101`\n",
    "    \n",
    "* Flottants (`f32`, `f64`) — e.g. `1.0`, `3.14`, `6.626e-34`\n",
    "* Booléen (`bool`) — e.g. `true`, `false`\n",
    "* Caractère (`char`) — e.g. `'&'`, `'ê'`, `'π'`, `'☃'` (unicode → 32 bits)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Tuples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "/// Retourne le quotient et le reste\n",
    "/// de la division euclidienne de a par b\n",
    "fn divmod(a: i64, b: i64) -> (i64, i64) {\n",
    "    (a/b, a%b)\n",
    "}\n",
    "\n",
    "let (q, r) = divmod(101, 42);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* Les tuples peuvent être hétérogènes (e.g. `(i32, f64, i32)`).\n",
    "* Les tuples peuvent être de taille quelconque (mais chaque type de tuple a une taille fixe).\n",
    "* Le type « tuple de taille zéro » `()` est appelé *unit* ou *nil* ;\n",
    "  c'est le type de retour implicite des fonctions ne retournant rien."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### Accéder aux champs d'un tuple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Le quotient est 2\n",
      "Le reste est 17\n"
     ]
    }
   ],
   "source": [
    "let t = divmod(101, 42);\n",
    "println!(\"Le quotient est {}\", t.0);\n",
    "println!(\"Le reste est {}\", t.1);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Tableaux"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "/// Retourne l'indice de la plus petite valeur de a\n",
    "fn imin(a: &[i64]) -> usize {\n",
    "    let mut im = 0;\n",
    "    for i in 1..a.len() {\n",
    "        if a[i] < a[im] {\n",
    "            im = i;\n",
    "        }\n",
    "    }\n",
    "    im\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "imin(&[11, 5, -8, 9])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* Pour tout type T, le type « tableau de T » s'écrit `[T]`\n",
    "  - En Rust, on l'appelle le type « tranche » (*slice*).\n",
    "  - NB: on reviendra plus tard sur le `&`\n",
    "* Une tranche « connait » sa taille, accessible par la méthode `len`.\n",
    "* L'accès aux éléments se fait avec la notation `a[i]`\n",
    "  - où `i` est de type `usize`.\n",
    "* L'accès à une sous-tranche se fait avec la notation `a[i..j]`.\n",
    "* L'accès à un indice invalide déclenchera *toujours* une erreur (≠ C, C++).\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Pas de conversion implicite"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "ename": "Error",
     "evalue": "mismatched types",
     "output_type": "error",
     "traceback": [
      "let y: f64 = x;",
      "\u001b[91m             ^\u001b[0m \u001b[94mexpected `f64`, found `f32`\u001b[0m",
      "let y: f64 = x;",
      "\u001b[91m       ^^^\u001b[0m \u001b[94mexpected due to this\u001b[0m",
      "mismatched types",
      "\u001b[1mhelp\u001b[0m: you can convert an `f32` to an `f64`\n\n.into()"
     ]
    }
   ],
   "source": [
    "// ce code ne compile pas\n",
    "let x: f32 = 1.5;\n",
    "let y: f64 = x;\n",
    "y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.5"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let x: f32 = 1.5;\n",
    "let y: f64 = x as f64;\n",
    "y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "⚠ Attention, cette conversion peut entraîner une perte d'information."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let f: f64 = 1.000000000001;\n",
    "f as f32"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let f = 2.5;\n",
    "f as i32"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "44"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let n: i16 = 300;\n",
    "n as i8"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4294967295"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let n: i32 = -1;\n",
    "n as u32"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Rigueur et souplesse"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Masquage (*shadowing*)\n",
    "\n",
    "* Rust autorise, y compris dans un même bloc de code,\n",
    "  à déclarer deux variables ayant le même nom.\n",
    "\n",
    "* La première est « masquée » par la deuxième\n",
    "  (on ne peut plus l'utiliser).\n",
    "  \n",
    "* On simule ainsi le fait de changer le type d'une variable\n",
    "  (comme en Python ou en Javascript, par exemple)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "42.0"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let mut answer = 20; // type i32\n",
    "answer = answer+1;\n",
    "answer = answer*2;\n",
    "let answer = answer as f64;\n",
    "answer"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "À utiliser avec précaution ; il est parfois plus judicieux (et plus lisible) d'utiliser un autre nom de variable."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Fonction générique (polymorphisme)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "/// Retourne l'indice de la plus petite valeur de a\n",
    "fn imin<T>(a: &[T]) -> usize \n",
    "//     ^^^      ^\n",
    "where T: PartialOrd\n",
    "{\n",
    "    let mut im = 0;\n",
    "    for i in 1..a.len() {\n",
    "        if a[i] < a[im] {\n",
    "            im = i;\n",
    "        }\n",
    "    }\n",
    "    im\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Les chevrons <> indiquent un paramètre générique.\n",
    "* La clause `where` ajoute des contraintes sur le type T : il doit supporter l'opérateur `<`.\n",
    "* Le compilateur générera une version de cette fonction pour chaque type avec laquelle on l'utilisera (« monomorphisation »)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "imin(&['h', 'b', 'g'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "imin(&[\"hello\", \"bonjour\", \"guten tag\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "imin(&[(10, 'h'), (20, 'b'), (10, 'g')])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Affichage et formatage"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x vaut 42\n",
      "y vaut 3.14 et z vaut false\n"
     ]
    }
   ],
   "source": [
    "let x = 42;\n",
    "let y = 3.14;\n",
    "let z = false;\n",
    "\n",
    "println!(\"x vaut {}\\ny vaut {} et z vaut {}\", x, y, z);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* `println!` attend comme premier paramètre une chaîne **litérale** décrivant le format\n",
    "* `{}` est un emplacement pour les valeurs supplémentaires passées à `println!`.\n",
    "* On peut placer des options entre les accolades.\n",
    "\n",
    "Documentation complète : https://doc.rust-lang.org/std/fmt/index.html#usage"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Exemples d'options de formatage"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1. 42\n",
      "2.  42\n",
      "3. 042\n",
      "4. 2A\n",
      "5. 101010\n",
      "6. 0000000000101010\n"
     ]
    }
   ],
   "source": [
    "let a = 42;\n",
    "println!(\"1. {}\", a);\n",
    "println!(\"2. {:3}\", a);    // largeur\n",
    "println!(\"3. {:03}\", a);   // largeur complétée par des zéros\n",
    "println!(\"4. {:X}\", a);    // hexadécimal\n",
    "println!(\"5. {:b}\", a);    // binaire\n",
    "println!(\"6. {:016b}\", a); // binaire sur 16 chiffres"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1. hello   | Z\n",
      "2. \"hello\" | 'Z' | ('a', 'z')\n"
     ]
    }
   ],
   "source": [
    "let txt = \"hello\";\n",
    "let c = 'Z';\n",
    "println!(\"1. {}   | {}\", txt, c);\n",
    "println!(\"2. {:?} | {:?} | {:?}\", txt, c, ('a','z')); // format \"debug\"\n"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "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
}