Séance 3 - Option et Result.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Introduction à Rust\n",
    "\n",
    "# Séance 3 – `Option` et `Result`\n",
    "\n",
    "[Pierre-Antoine Champin](http://champin.net/)\n",
    "\n",
    "Département Info Doua – [IUT Lyon 1](http://iut.univ-lyon1.fr/)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Le type `Option` 🦀"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Motivation\n",
    "\n",
    "* En Java, une fonction dont le type de retour est `MyObject` peut en général retourner une instance de `MyObjet` ou `null`. (Idem en C avec une fonction qui retourne un pointeur).\n",
    "\n",
    "* Ceci est une entorse au système de typage, car `null` n'est *pas* du type `MyObject`:\n",
    "\n",
    "    + il n'a aucune des méthodes de cette classe,\n",
    "    + et toute tentative de l'utiliser comme tel déclenchera une erreur (`NullPointerException`).\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* En Rust, une fonction dont le type de retour est `T` doit retourner une valeur de ce type.\n",
    "\n",
    "* Mais il y a pourtant des cas où on souhaite pouvoir retourner « un `T` ou rien du tout »... Exemples :\n",
    "\n",
    "    + la méthode `pop()` du type `Vec<T>` retire le dernier élément du vecteur *et retourne sa valeur*,\n",
    "      mais ne fait rien (et ne retourne rien) si le vecteur était déjà vide ;\n",
    "\n",
    "    + la méthode `get(i)` du type `[T]` retourne l'élément d'indice *i* s'il existe,\n",
    "      ou rien si *i* est trop grand. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* Le type de retour de ces méthodes est `Option<T>` ; les valeurs de ce type peuvent être :\n",
    "\n",
    "    * `None`, qui représente l'absence de valeur, ou\n",
    "    * `Some(t)`, où *t* est une valeur de type `T`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### `Option<T>` en action"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Some(3)"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fn safe_sub(a: u32, b: u32) -> Option<u32> {\n",
    "    if a >= b {\n",
    "        Some(a-b)\n",
    "    } else {\n",
    "        None\n",
    "    }\n",
    "}\n",
    "\n",
    "safe_sub(5,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Le résultat est 3.\n"
     ]
    }
   ],
   "source": [
    "match safe_sub(5, 2) {\n",
    "    None => println!(\"Le résultat serait négatif.\"),\n",
    "    Some(r) => println!(\"Le résultat est {}.\", r),\n",
    "};"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'-'"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "// rappel: la clause match est une expression\n",
    "let c = match safe_sub(2, 5) {\n",
    "    None => '-',\n",
    "    Some(0) => '0',\n",
    "    Some(_) => '+',\n",
    "};\n",
    "c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Les méthodes `expect` et `unwrap`\n",
    "\n",
    "Lorsqu'on ne souhaite pas traiter le cas ou une option vaut `None`,\n",
    "on peut utiliser sa méthode `expect(message)` :\n",
    "\n",
    "* pour `Some(t)`, elle retourne `t`;\n",
    "* pour `None`, elle interrompt le programme (panique) en affichant le message passé en paramètre."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "let mut v = vec![1,1,2,3,5];\n",
    "let val: i32 = v.pop().expect(\"v ne devrait pas être vide\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La méthode `unwrap` fonctionne de la même manière, mais ne prend pas de paramètre.\n",
    "Elle affichera un message par défaut en cas de panique."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Le type `Result` 🦀"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Motivation\n",
    "\n",
    "* Dans certaines situations, le fait de ne pas retourner une valeur du type attendu est un comportement *anormal*.\n",
    "\n",
    "    + On souhaite alors pouvoir connaître la *raison* de cette anomalie.\n",
    "    \n",
    "* Pour ces situations, Rust fournit le type `Result<T,E>`, dont les valeurs peuvent être :\n",
    "\n",
    "    + `Ok(t)` où *t* est de type `T`, et qui représente le résultat normal de l'opération, ou\n",
    "    + `Err(e)` où *e* est de type `E`, et représente une anomalie dont *e* est une explication."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### `Result<T, E>` en action"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Ok(87.5)"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fn vitesse(distance: f64, temps: f64) -> Result<f64, &'static str> {\n",
    "    if distance < 0.0 {\n",
    "        Err(\"distance ne peut pas être négative\")\n",
    "    } else if temps < 0.0 {\n",
    "        Err(\"temps ne peut pas être négatif\")\n",
    "    } else if temps == 0.0 {\n",
    "        Err(\"le temps est nul, la vitesse serait infinie\")\n",
    "    } else {\n",
    "        Ok(distance/temps)\n",
    "    }\n",
    "}\n",
    "\n",
    "vitesse(70.0, 0.8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Votre vitesse est de 87.5 km/h\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "match vitesse(70.0, 0.8) {\n",
    "    Err(msg) => eprintln!(\"Erreur: {}\", msg),\n",
    "    Ok(v) => if v>130.0 {\n",
    "            println!(\"Vous allez beaucoup trop vite !\");\n",
    "        } else {\n",
    "            println!(\"Votre vitesse est de {} km/h\", v);\n",
    "        }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "NB: le type `Result<T, E>` a lui aussi une méthode `expect(message)` et une méthode `unwrap()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "let v: f64 = vitesse(70.0, 0.8).unwrap();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Faire remonter une erreur"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "fn vitesse_moyenne(d1: f64, t1: f64, d2: f64, t2: f64) -> Result<f32, &'static str> {\n",
    "    let v1 = match vitesse(d1, t1) {\n",
    "        Ok(v) => v,\n",
    "        Err(err) => return Err(err),\n",
    "    };\n",
    "    let v2 = match vitesse(d2, t2) {\n",
    "        Ok(v) => v,\n",
    "        Err(err) => return Err(err),\n",
    "    };\n",
    "    Ok(((v1+v2)/2.0) as f32)\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "fn vitesse_moyenne2(d1: f64, t1: f64, d2: f64, t2: f64) -> Result<f32, &'static str> {\n",
    "    let v1 = vitesse(d1, t1)?;\n",
    "    let v2 = vitesse(d2, t2)?;\n",
    "    Ok(((v1+v2)/2.0) as f32)\n",
    "}"
   ]
  }
 ],
 "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
}