{"id":7876,"date":"2021-01-15T00:00:00","date_gmt":"2021-01-14T23:00:00","guid":{"rendered":"https:\/\/blog.ouidou.fr\/?p=7876"},"modified":"2024-11-07T11:20:45","modified_gmt":"2024-11-07T10:20:45","slug":"principe-du-parapluie","status":"publish","type":"post","link":"https:\/\/ouidou.fr\/blog\/articles-techniques\/principe-du-parapluie","title":{"rendered":"Principe du parapluie"},"content":{"rendered":"<p><em>Article \u00e9crit par Fran\u00e7ois Vantomme<\/em><\/p>\n<p>Il est possible de penser juste avec des choses qui n\u2019existent pas. \u00c0 vrai dire, c\u2019est m\u00eame le propre de l\u2019informatique que de penser des choses qui n\u2019existent pas. C\u2019est-\u00e0-dire des choses abstraites.<\/p>\n<p>Je paraphrase ici un extrait du livre \u00ab\u00a0Le th\u00e9or\u00e8me du parapluie, ou l\u2019art d\u2019observer le monde dans le bon sens\u00a0\u00bb de Micka\u00ebl Launay. Alors bien \u00e9videmment, lui nous parle de math\u00e9matiques, mais c\u2019est tout \u00e0 fait transposable \u00e0 l\u2019informatique et plus pr\u00e9cis\u00e9ment au d\u00e9veloppement logiciel.<\/p>\n<p>Je vous invite aujourd\u2019hui \u00e0 observer sous un angle diff\u00e9rent des situations qui nous sont famili\u00e8res. Nous avons pu constater, dans un pr\u00e9c\u00e9dent article, que Rails n\u2019est pas simple. Ainsi, plut\u00f4t que de cacher la complexit\u00e9 sous le tapis du <em>framework<\/em>, voyons comment s\u2019en sortir \u00e9l\u00e9gamment avec un pas de c\u00f4t\u00e9.<\/p>\n<h2 id=\"principe-du-parapluie\">Principe du parapluie<\/h2>\n<p>Ce principe porte le nom d\u2019<a href=\"https:\/\/fr.wikipedia.org\/wiki\/Automorphisme_int%C3%A9rieur\">automorphisme int\u00e9rieur<\/a> pour les f\u00e9rus de maths, mais j\u2019ai pr\u00e9f\u00e9r\u00e9 ici conserver le nom que lui a donn\u00e9 Micka\u00ebl Launay dans son livre de vulgarisation. D\u2019autant plus que nous ne rentrerons pas dans les m\u00e9andres de la th\u00e9orie des groupes. Loin de moi l\u2019envie de vous perdre d\u00e8s le quatri\u00e8me paragraphe\u00a0! Et en toute honn\u00eatet\u00e9, \u00e7a d\u00e9passe de tr\u00e8s loin mes comp\u00e9tences.<\/p>\n<p>Mais ce principe, \u00e9nonc\u00e9 de mani\u00e8re concise et en des termes compr\u00e9hensibles par tous, nous sera tr\u00e8s utile pour la suite. Il consiste en trois \u00e9tapes\u00a0:<\/p>\n<ol>\n<li>Inventer un monde dans lequel mod\u00e9liser notre question\u00a0;<\/li>\n<li>R\u00e9soudre le probl\u00e8me dans ce monde\u00a0;<\/li>\n<li>Transf\u00e9rer le r\u00e9sultat dans le monde r\u00e9el.<\/li>\n<\/ol>\n<p>Autrement dit, inventons-nous une petite bulle dans laquelle les situations les plus alambiqu\u00e9es sont faciles \u00e0 r\u00e9soudre. Pour reprendre la m\u00e9taphore du parapluie, imaginons que vous souhaitiez traverser la rue sous une pluie battante sans vous mouiller. Voici la proc\u00e9dure\u00a0:<\/p>\n<ol>\n<li>Ouvrez votre parapluie\u00a0;<\/li>\n<li>Traversez la rue\u00a0;<\/li>\n<li>Refermez votre parapluie.<\/li>\n<\/ol>\n<p>Simple, non\u00a0? Encore fallait-il avoir eu l\u2019id\u00e9e du parapluie\u00a0!<\/p>\n<h2 id=\"et-si-on-faisait-un-essai\">Et si on faisait un essai\u00a0?<\/h2>\n<p>Prenons un exemple assez commun. Mettons que nous voulions connaitre le nom de la province dans laquelle r\u00e9side un citoyen.<\/p>\n<div class=\"language-ruby highlighter-rouge\">\n<div class=\"highlight\">\n<pre class=\"highlight\"><code><span class=\"c1\"># @param id [Integer] a citizen identifier<\/span> <span class=\"c1\"># @return [String] the found state name<\/span> <span class=\"k\">def<\/span> <span class=\"nf\">citizen_state<\/span><span class=\"p\">(<\/span><span class=\"nb\">id<\/span><span class=\"p\">)<\/span>   <span class=\"n\">citizen<\/span> <span class=\"o\">=<\/span> <span class=\"no\">Citizen<\/span><span class=\"p\">.<\/span><span class=\"nf\">find_by<\/span><span class=\"p\">(<\/span><span class=\"ss\">id: <\/span><span class=\"nb\">id<\/span><span class=\"p\">)<\/span>   <span class=\"n\">citizen<\/span><span class=\"p\">.<\/span><span class=\"nf\">address<\/span><span class=\"p\">.<\/span><span class=\"nf\">city<\/span><span class=\"p\">.<\/span><span class=\"nf\">state<\/span><span class=\"p\">.<\/span><span class=\"nf\">name<\/span> <span class=\"k\">end<\/span> <\/code><\/pre>\n<\/div>\n<\/div>\n<p>Malheureusement, c\u2019est rarement si simple\u00a0! Il se peut en effet qu\u2019aucune province n\u2019ait \u00e9t\u00e9 renseign\u00e9e, voire qu\u2019aucune adresse n\u2019ait \u00e9t\u00e9 renseign\u00e9e pour ce citoyen. Autrement dit, n\u2019importe laquelle des m\u00e9thodes que l\u2019on chaine ici peut, pour une raison ou une autre, retourner <code>nil<\/code>.<\/p>\n<blockquote><p><a href=\"http:\/\/www.cs.ox.ac.uk\/people\/tony.hoare\/\">Tony Hoare<\/a> a invent\u00e9 le <code>nil<\/code> (<a href=\"https:\/\/en.wikipedia.org\/wiki\/Null_pointer\"><em>null pointer<\/em><\/a>) en 1965\u00a0; il l\u2019appelle maintenant son \u00ab\u00a0<a href=\"https:\/\/www.infoq.com\/presentations\/Null-References-The-Billion-Dollar-Mistake-Tony-Hoare\/\">erreur d\u2019un milliard de dollars<\/a>\u00a0\u00bb, qui a \u00ab\u00a0probablement caus\u00e9 un milliard de dollars de douleur et de d\u00e9g\u00e2ts\u00a0\u00bb.<\/p><\/blockquote>\n<p>C\u2019est peut-\u00eatre une erreur, mais Ruby a cette notion en son sein et nous devons faire avec. Ce genre de situation, o\u00f9 l\u2019on doit tol\u00e9rer l\u2019\u00e9ventuelle pr\u00e9sence d\u2019un <code>nil<\/code> en retour de m\u00e9thode, est tellement fr\u00e9quent que le framework Rails, \u00e0 travers ActiveSupport, a tr\u00e8s t\u00f4t propos\u00e9 un palliatif sous la forme d\u2019une m\u00e9thode nomm\u00e9e <code>try<\/code>.<\/p>\n<div class=\"language-ruby highlighter-rouge\">\n<div class=\"highlight\">\n<pre class=\"highlight\"><code><span class=\"c1\"># @param id [Integer] a citizen identifier<\/span> <span class=\"c1\"># @return [String] the found state name<\/span> <span class=\"k\">def<\/span> <span class=\"nf\">citizen_state<\/span><span class=\"p\">(<\/span><span class=\"nb\">id<\/span><span class=\"p\">)<\/span>   <span class=\"n\">citizen<\/span> <span class=\"o\">=<\/span> <span class=\"no\">Citizen<\/span><span class=\"p\">.<\/span><span class=\"nf\">find_by<\/span><span class=\"p\">(<\/span><span class=\"ss\">id: <\/span><span class=\"nb\">id<\/span><span class=\"p\">)<\/span>   <span class=\"n\">citizen<\/span><span class=\"p\">.<\/span><span class=\"nf\">try<\/span><span class=\"p\">(<\/span><span class=\"ss\">:address<\/span><span class=\"p\">).<\/span><span class=\"nf\">try<\/span><span class=\"p\">(<\/span><span class=\"ss\">:city<\/span><span class=\"p\">).<\/span><span class=\"nf\">try<\/span><span class=\"p\">(<\/span><span class=\"ss\">:state<\/span><span class=\"p\">).<\/span><span class=\"nf\">try<\/span><span class=\"p\">(<\/span><span class=\"ss\">:name<\/span><span class=\"p\">)<\/span> <span class=\"k\">end<\/span> <\/code><\/pre>\n<\/div>\n<\/div>\n<p>Cette approche ne semble pas trop mal, mais nous pouvons cependant lui reprocher une chose\u00a0: <code>try<\/code> n\u2019est autre qu\u2019un <a href=\"https:\/\/github.com\/rails\/rails\/blob\/6-1-stable\/activesupport\/lib\/active_support\/core_ext\/object\/try.rb\"><em>monkey patch<\/em> assez grossier<\/a> sur les classes <code>Object<\/code>, <code>NilClass<\/code> et <code>Delegator<\/code>.<\/p>\n<p>Mais depuis Ruby 2.3, nous avons un nouvel op\u00e9rateur \u00e0 disposition, j\u2019ai nomm\u00e9 le <em>safe navigation operator<\/em> (<code>&amp;.<\/code>). Utiliser un \u00e9l\u00e9ment du langage, c\u2019est d\u00e9j\u00e0 beaucoup mieux\u00a0! Voyons ce que \u00e7a donne.<\/p>\n<div class=\"language-ruby highlighter-rouge\">\n<div class=\"highlight\">\n<pre class=\"highlight\"><code><span class=\"c1\"># @param id [Integer] a citizen identifier<\/span> <span class=\"c1\"># @return [String] the found state name<\/span> <span class=\"k\">def<\/span> <span class=\"nf\">citizen_state<\/span><span class=\"p\">(<\/span><span class=\"nb\">id<\/span><span class=\"p\">)<\/span>   <span class=\"n\">citizen<\/span> <span class=\"o\">=<\/span> <span class=\"no\">Citizen<\/span><span class=\"p\">.<\/span><span class=\"nf\">find_by<\/span><span class=\"p\">(<\/span><span class=\"ss\">id: <\/span><span class=\"nb\">id<\/span><span class=\"p\">)<\/span>   <span class=\"n\">citizen<\/span><span class=\"o\">&amp;<\/span><span class=\"p\">.<\/span><span class=\"nf\">address<\/span><span class=\"o\">&amp;<\/span><span class=\"p\">.<\/span><span class=\"nf\">city<\/span><span class=\"o\">&amp;<\/span><span class=\"p\">.<\/span><span class=\"nf\">state<\/span><span class=\"o\">&amp;<\/span><span class=\"p\">.<\/span><span class=\"nf\">name<\/span> <span class=\"k\">end<\/span> <\/code><\/pre>\n<\/div>\n<\/div>\n<p>Pas mal. Mais nous avons toujours un petit probl\u00e8me. En effet, l\u2019usage de cet op\u00e9rateur ne nous garantit pas que la valeur de retour de notre m\u00e9thode sera bien une chaine de caract\u00e8res. On peut se retrouver avec un <code>nil<\/code>. Il ne faut alors pas oublier de fournir une valeur par d\u00e9faut en solution de repli.<\/p>\n<div class=\"language-ruby highlighter-rouge\">\n<div class=\"highlight\">\n<pre class=\"highlight\"><code><span class=\"c1\"># @param id [Integer] a citizen identifier<\/span> <span class=\"c1\"># @return [String] the found state name<\/span> <span class=\"k\">def<\/span> <span class=\"nf\">citizen_state<\/span><span class=\"p\">(<\/span><span class=\"nb\">id<\/span><span class=\"p\">)<\/span>   <span class=\"n\">citizen<\/span> <span class=\"o\">=<\/span> <span class=\"no\">Citizen<\/span><span class=\"p\">.<\/span><span class=\"nf\">find_by<\/span><span class=\"p\">(<\/span><span class=\"ss\">id: <\/span><span class=\"nb\">id<\/span><span class=\"p\">)<\/span>   <span class=\"n\">citizen<\/span><span class=\"o\">&amp;<\/span><span class=\"p\">.<\/span><span class=\"nf\">address<\/span><span class=\"o\">&amp;<\/span><span class=\"p\">.<\/span><span class=\"nf\">city<\/span><span class=\"o\">&amp;<\/span><span class=\"p\">.<\/span><span class=\"nf\">state<\/span><span class=\"o\">&amp;<\/span><span class=\"p\">.<\/span><span class=\"nf\">name<\/span> <span class=\"o\">||<\/span> <span class=\"s2\">\"No state\"<\/span> <span class=\"k\">end<\/span> <\/code><\/pre>\n<\/div>\n<\/div>\n<p>Bon, maintenant prenons un peu de recul. Il y a quelque chose d\u2019in\u00e9l\u00e9gant dans cette approche. Elle donne l\u2019impression de constamment ouvrir et fermer son parapluie, \u00e0 chaque petit pas, pour \u00e9viter qu\u2019un <code>nil<\/code> ne nous tombe dessus. Ne pourrions-nous pas cr\u00e9er un petit monde o\u00f9 la pr\u00e9sence \u00e9ventuelle d\u2019un <code>nil<\/code> est g\u00e9r\u00e9e \u00e9l\u00e9gamment, et ne r\u00e9cup\u00e9rer le r\u00e9sultat \u2014\u00a0c\u2019est-\u00e0-dire refermer notre parapluie\u00a0\u2014 qu\u2019en toute fin\u00a0?<\/p>\n<h2 id=\"peut-tre\">Peut-\u00eatre\u2026<\/h2>\n<p>Pour nous \u00e9lever vers ce monde merveilleux o\u00f9 l\u2019absence de valeur significative nous glisse dessus sans m\u00eame nous \u00e9mouvoir, nous aurons besoin d\u2019encapsuler notre objet <code>citizen<\/code> dans une instance de classe que nous nommerons <code>Maybe<\/code>.<\/p>\n<div class=\"language-ruby highlighter-rouge\">\n<div class=\"highlight\">\n<pre class=\"highlight\"><code><span class=\"c1\"># @param id [Integer] a citizen identifier<\/span> <span class=\"c1\"># @return [String] the found state name<\/span> <span class=\"k\">def<\/span> <span class=\"nf\">citizen_state<\/span><span class=\"p\">(<\/span><span class=\"nb\">id<\/span><span class=\"p\">)<\/span>   <span class=\"n\">citizen<\/span> <span class=\"o\">=<\/span> <span class=\"no\">Citizen<\/span><span class=\"p\">.<\/span><span class=\"nf\">find_by<\/span><span class=\"p\">(<\/span><span class=\"ss\">id: <\/span><span class=\"nb\">id<\/span><span class=\"p\">)<\/span>    <span class=\"n\">state_name<\/span> <span class=\"o\">=<\/span> <span class=\"no\">Maybe<\/span><span class=\"p\">(<\/span><span class=\"n\">citizen<\/span><span class=\"p\">).<\/span>                  <span class=\"nf\">maybe<\/span><span class=\"p\">(<\/span><span class=\"o\">&amp;<\/span><span class=\"ss\">:address<\/span><span class=\"p\">).<\/span>                  <span class=\"nf\">maybe<\/span><span class=\"p\">(<\/span><span class=\"o\">&amp;<\/span><span class=\"ss\">:city<\/span><span class=\"p\">).<\/span>                  <span class=\"nf\">maybe<\/span><span class=\"p\">(<\/span><span class=\"o\">&amp;<\/span><span class=\"ss\">:state<\/span><span class=\"p\">).<\/span>                  <span class=\"nf\">maybe<\/span><span class=\"p\">(<\/span><span class=\"o\">&amp;<\/span><span class=\"ss\">:name<\/span><span class=\"p\">)<\/span>    <span class=\"n\">state_name<\/span><span class=\"p\">.<\/span><span class=\"nf\">value_or<\/span><span class=\"p\">(<\/span><span class=\"s2\">\"No state\"<\/span><span class=\"p\">)<\/span> <span class=\"k\">end<\/span> <\/code><\/pre>\n<\/div>\n<\/div>\n<p>Ici, <code>Maybe<\/code> retournera soit une instance de <code>Some(citizen)<\/code>, soit <code>None<\/code>. Toutes deux sont des classes qui h\u00e9ritent de <code>Maybe<\/code>. Elles partagent donc le m\u00eame comportement. L\u2019appel \u00e0 la m\u00e9thode <code>maybe<\/code> retournera lui aussi soit une instance de <code>Some<\/code>, soit <code>None<\/code>, c\u2019est-\u00e0-dire un autre <code>Maybe<\/code>. Ainsi, nos m\u00e9thodes retournent toutes \u00e0 pr\u00e9sent une structure de donn\u00e9es bien ma\u00eetris\u00e9e.<\/p>\n<p>Bien \u00e9videmment, l\u2019impl\u00e9mentation de cette m\u00e9thode <code>maybe<\/code> diff\u00e8re selon qu\u2019on l\u2019appelle sur l\u2019une ou l\u2019autre classe. Dans le cas de <code>None<\/code>, nous avons affaire \u00e0 un singleton qui se retourne lui-m\u00eame, tout b\u00eatement. Pas de valeur, pas de traitement.<\/p>\n<div class=\"language-ruby highlighter-rouge\">\n<div class=\"highlight\">\n<pre class=\"highlight\"><code><span class=\"c1\"># Represents an absence of a value, i.e. the value nil.<\/span> <span class=\"c1\">#<\/span> <span class=\"k\">class<\/span> <span class=\"nc\">None<\/span> <span class=\"o\">&lt;<\/span> <span class=\"no\">Maybe<\/span>   <span class=\"vi\">@instance<\/span> <span class=\"o\">=<\/span> <span class=\"n\">new<\/span><span class=\"p\">.<\/span><span class=\"nf\">freeze<\/span>   <span class=\"n\">singleton_class<\/span><span class=\"p\">.<\/span><span class=\"nf\">send<\/span><span class=\"p\">(<\/span><span class=\"ss\">:attr_reader<\/span><span class=\"p\">,<\/span> <span class=\"ss\">:instance<\/span><span class=\"p\">)<\/span>    <span class=\"c1\"># Ignores the input parameter and returns self.<\/span>   <span class=\"c1\"># It exists to keep the interface identical to that of {Some}.<\/span>   <span class=\"c1\">#<\/span>   <span class=\"k\">def<\/span> <span class=\"nf\">maybe<\/span><span class=\"p\">(<\/span><span class=\"o\">*<\/span><span class=\"p\">)<\/span>     <span class=\"nb\">self<\/span>   <span class=\"k\">end<\/span> <span class=\"k\">end<\/span> <\/code><\/pre>\n<\/div>\n<\/div>\n<p>En ce qui concerne <code>Some<\/code>, l\u00e0 c\u2019est un peu diff\u00e9rent. Ce que l\u2019on va vouloir faire c\u2019est appliquer un traitement sur la valeur contenue dans notre instance de <code>Some<\/code>, puis encapsuler le r\u00e9sultat dans une nouvelle instance de <code>Maybe<\/code>. Ainsi, nous nous assurons de toujours retourner une instance de <code>Maybe<\/code>, ce qui nous permettra de chainer les appels.<\/p>\n<div class=\"language-ruby highlighter-rouge\">\n<div class=\"highlight\">\n<pre class=\"highlight\"><code><span class=\"c1\"># Represents a value that is present, i.e. not nil.<\/span> <span class=\"c1\">#<\/span> <span class=\"k\">class<\/span> <span class=\"nc\">Some<\/span> <span class=\"o\">&lt;<\/span> <span class=\"no\">Maybe<\/span>   <span class=\"c1\"># Does the same thing as #bind except it also wraps the value<\/span>   <span class=\"c1\"># in an instance of Maybe::Some monad. This allows for easier<\/span>   <span class=\"c1\"># chaining of calls.<\/span>   <span class=\"c1\">#<\/span>   <span class=\"c1\"># @param args [Array&lt;Object&gt;] arguments will be passed through to #bind<\/span>   <span class=\"c1\"># @return [Maybe::Some, Maybe::None] Wrapped result,<\/span>   <span class=\"c1\">#                                    i.e. nil will be mapped to None,<\/span>   <span class=\"c1\">#                                    other values will be wrapped with Some<\/span>   <span class=\"c1\">#<\/span>   <span class=\"k\">def<\/span> <span class=\"nf\">maybe<\/span><span class=\"p\">(<\/span><span class=\"o\">*<\/span><span class=\"n\">args<\/span><span class=\"p\">,<\/span> <span class=\"o\">&amp;<\/span><span class=\"n\">block<\/span><span class=\"p\">)<\/span>     <span class=\"no\">Maybe<\/span><span class=\"p\">.<\/span><span class=\"nf\">coerce<\/span><span class=\"p\">(<\/span><span class=\"n\">bind<\/span><span class=\"p\">(<\/span><span class=\"o\">*<\/span><span class=\"n\">args<\/span><span class=\"p\">,<\/span> <span class=\"o\">&amp;<\/span><span class=\"n\">block<\/span><span class=\"p\">))<\/span>   <span class=\"k\">end<\/span> <span class=\"k\">end<\/span> <\/code><\/pre>\n<\/div>\n<\/div>\n<p>Comme on peut le constater, l\u2019appel \u00e0 <code>bind<\/code> s\u2019occupe de faire le traitement, puis on encapsule le tout \u00e0 l\u2019aide de <code>Maybe.coerce<\/code>. Jetons un \u0153il \u00e0 ce dernier pour commencer, vous allez voir, rien de sorcier ici.<\/p>\n<div class=\"language-ruby highlighter-rouge\">\n<div class=\"highlight\">\n<pre class=\"highlight\"><code><span class=\"c1\"># Represents a value which can exist or not, i.e. it could be nil.<\/span> <span class=\"c1\">#<\/span> <span class=\"k\">class<\/span> <span class=\"nc\">Maybe<\/span>   <span class=\"k\">class<\/span> <span class=\"o\">&lt;&lt;<\/span> <span class=\"nb\">self<\/span>     <span class=\"c1\"># Wraps the given value with into a Maybe object.<\/span>     <span class=\"c1\">#<\/span>     <span class=\"c1\"># @param value [Object] value to be stored in<\/span>     <span class=\"c1\"># @return [Maybe::Some, Maybe::None]<\/span>     <span class=\"k\">def<\/span> <span class=\"nf\">coerce<\/span><span class=\"p\">(<\/span><span class=\"n\">value<\/span><span class=\"p\">)<\/span>       <span class=\"k\">if<\/span> <span class=\"n\">value<\/span><span class=\"p\">.<\/span><span class=\"nf\">nil?<\/span>         <span class=\"no\">None<\/span><span class=\"p\">.<\/span><span class=\"nf\">instance<\/span>       <span class=\"k\">else<\/span>         <span class=\"no\">Some<\/span><span class=\"p\">.<\/span><span class=\"nf\">new<\/span><span class=\"p\">(<\/span><span class=\"n\">value<\/span><span class=\"p\">)<\/span>       <span class=\"k\">end<\/span>     <span class=\"k\">end<\/span>   <span class=\"k\">end<\/span> <span class=\"k\">end<\/span> <\/code><\/pre>\n<\/div>\n<\/div>\n<p>OK. Si la valeur qu\u2019on lui passe est <code>nil<\/code>, on retourne l\u2019instance de notre singleton <code>None<\/code>, sinon on cr\u00e9e une nouvelle instance de <code>Some<\/code> avec ladite valeur en argument.<\/p>\n<p>Et <code>bind<\/code> alors\u00a0? L\u00e0 \u00e7a peut paraitre un peu complexe \u00e0 la lecture, mais tout ce que \u00e7a fait c\u2019est appliquer un block ayant notre valeur en argument, ou appeler la m\u00e9thode <code>call<\/code> sur l\u2019objet qu\u2019on lui aurait donn\u00e9 en param\u00e8tre. Voici quelques exemples pour clarifier le propos\u00a0:<\/p>\n<div class=\"language-ruby highlighter-rouge\">\n<div class=\"highlight\">\n<pre class=\"highlight\"><code><span class=\"no\">Some<\/span><span class=\"p\">(<\/span><span class=\"mi\">5<\/span><span class=\"p\">).<\/span><span class=\"nf\">bind<\/span><span class=\"p\">(<\/span><span class=\"o\">&amp;<\/span><span class=\"ss\">:succ<\/span><span class=\"p\">)<\/span>           <span class=\"c1\"># === 5.succ<\/span> <span class=\"o\">=&gt;<\/span> <span class=\"mi\">6<\/span>  <span class=\"no\">Some<\/span><span class=\"p\">(<\/span><span class=\"mi\">5<\/span><span class=\"p\">).<\/span><span class=\"nf\">bind<\/span> <span class=\"p\">{<\/span> <span class=\"o\">|<\/span><span class=\"n\">i<\/span><span class=\"o\">|<\/span> <span class=\"n\">i<\/span><span class=\"p\">.<\/span><span class=\"nf\">succ<\/span> <span class=\"p\">}<\/span>    <span class=\"c1\"># === 5.succ<\/span> <span class=\"o\">=&gt;<\/span> <span class=\"mi\">6<\/span>  <span class=\"no\">Some<\/span><span class=\"p\">(<\/span><span class=\"mi\">5<\/span><span class=\"p\">).<\/span><span class=\"nf\">bind<\/span><span class=\"p\">(<\/span><span class=\"o\">-&gt;<\/span><span class=\"p\">(<\/span><span class=\"n\">i<\/span><span class=\"p\">)<\/span> <span class=\"p\">{<\/span> <span class=\"n\">i<\/span><span class=\"p\">.<\/span><span class=\"nf\">succ<\/span> <span class=\"p\">})<\/span> <span class=\"c1\"># === proc { |i| i.succ }.call(5)<\/span> <span class=\"o\">=&gt;<\/span> <span class=\"mi\">6<\/span>  <span class=\"n\">plusplus<\/span> <span class=\"o\">=<\/span> <span class=\"mi\">1<\/span><span class=\"p\">.<\/span><span class=\"nf\">method<\/span><span class=\"p\">(<\/span><span class=\"s2\">\"+\"<\/span><span class=\"p\">)<\/span> <span class=\"o\">=&gt;<\/span> <span class=\"c1\">#&lt;Method: Integer#+(_)&gt;<\/span> <span class=\"no\">Some<\/span><span class=\"p\">(<\/span><span class=\"mi\">5<\/span><span class=\"p\">).<\/span><span class=\"nf\">bind<\/span><span class=\"p\">(<\/span><span class=\"n\">plusplus<\/span><span class=\"p\">)<\/span>         <span class=\"c1\"># === plusplus.call(5)<\/span> <span class=\"o\">=&gt;<\/span> <span class=\"mi\">6<\/span>  <span class=\"no\">Some<\/span><span class=\"p\">(<\/span><span class=\"mi\">5<\/span><span class=\"p\">).<\/span><span class=\"nf\">bind<\/span> <span class=\"c1\"># NoMethodError: undefined method `call' for nil:NilClass<\/span> <\/code><\/pre>\n<\/div>\n<\/div>\n<h3 id=\"refermer-le-parapluie\">Refermer le parapluie<\/h3>\n<p>Nous avons ouvert notre parapluie en nous installant dans le monde r\u00e9confortant de <code>Maybe<\/code> o\u00f9 nous pouvons chainer nos appels sans \u00eatre constamment sur la d\u00e9fensive au cas o\u00f9 un <code>nil<\/code> nous tomberait sur le coin du nez. Seulement maintenant, il est temps de redescendre, de fermer notre parapluie et de retourner le tant attendu nom de la province de notre citoyen. Pour cela, nous allons faire appel \u00e0 la m\u00e9thode <code>value_or<\/code> qui, comme vous vous y attendez, aura une impl\u00e9mentation diff\u00e9rente selon qu\u2019on l\u2019appelle sur une instance de <code>Some<\/code> ou sur <code>None<\/code>.<\/p>\n<div class=\"language-ruby highlighter-rouge\">\n<div class=\"highlight\">\n<pre class=\"highlight\"><code><span class=\"k\">class<\/span> <span class=\"nc\">Some<\/span> <span class=\"o\">&lt;<\/span> <span class=\"no\">Maybe<\/span>   <span class=\"c1\"># Returns value. It exists to keep the interface identical to that of {None}<\/span>   <span class=\"c1\">#<\/span>   <span class=\"c1\"># @return [Object]<\/span>   <span class=\"k\">def<\/span> <span class=\"nf\">value_or<\/span><span class=\"p\">(<\/span><span class=\"n\">_val<\/span> <span class=\"o\">=<\/span> <span class=\"kp\">nil<\/span><span class=\"p\">)<\/span>     <span class=\"vi\">@value<\/span>   <span class=\"k\">end<\/span> <span class=\"k\">end<\/span>  <span class=\"k\">class<\/span> <span class=\"nc\">None<\/span> <span class=\"o\">&lt;<\/span> <span class=\"no\">Maybe<\/span>   <span class=\"c1\"># Returns the passed value<\/span>   <span class=\"c1\">#<\/span>   <span class=\"c1\"># @return [Object]<\/span>   <span class=\"k\">def<\/span> <span class=\"nf\">value_or<\/span><span class=\"p\">(<\/span><span class=\"n\">val<\/span> <span class=\"o\">=<\/span> <span class=\"kp\">nil<\/span><span class=\"p\">)<\/span>     <span class=\"k\">if<\/span> <span class=\"nb\">block_given?<\/span>       <span class=\"k\">yield<\/span>     <span class=\"k\">else<\/span>       <span class=\"n\">val<\/span>     <span class=\"k\">end<\/span>   <span class=\"k\">end<\/span> <span class=\"k\">end<\/span> <\/code><\/pre>\n<\/div>\n<\/div>\n<p>Dans le cas de <code>Some<\/code> on retournera la valeur que contient celui-ci, alors que pour <code>None<\/code> on retournera le r\u00e9sultat d\u2019ex\u00e9cution du bloc, ou la valeur pass\u00e9e en param\u00e8tre \u00e0 la m\u00e9thode <code>value_or<\/code>.<\/p>\n<p>R\u00e9sumons-nous. Qu\u2019avons-nous fait\u00a0? Nous avons envelopp\u00e9 (ou d\u00e9cor\u00e9) notre objet initial avec <code>Maybe<\/code>. Et ce faisant, nous sommes en capacit\u00e9 de chainer de multiples appels, et certains de r\u00e9cup\u00e9rer une valeur, quelle qu\u2019elle soit, envelopp\u00e9e \u00e0 son tour dans un <code>Maybe<\/code>. Quand on a finalement besoin de la valeur, on la d\u00e9couvre en ouvrant l\u2019enveloppe.<\/p>\n<div class=\"language-ruby highlighter-rouge\">\n<div class=\"highlight\">\n<pre class=\"highlight\"><code><span class=\"no\">Maybe<\/span><span class=\"p\">(<\/span><span class=\"n\">citizen<\/span><span class=\"p\">).<\/span><span class=\"nf\">maybe<\/span><span class=\"p\">(<\/span><span class=\"o\">&amp;<\/span><span class=\"ss\">:address<\/span><span class=\"p\">).<\/span><span class=\"nf\">maybe<\/span><span class=\"p\">(<\/span><span class=\"o\">&amp;<\/span><span class=\"ss\">:city<\/span><span class=\"p\">).<\/span><span class=\"nf\">maybe<\/span><span class=\"p\">(<\/span><span class=\"o\">&amp;<\/span><span class=\"ss\">:state<\/span><span class=\"p\">).<\/span><span class=\"nf\">maybe<\/span><span class=\"p\">(<\/span><span class=\"o\">&amp;<\/span><span class=\"ss\">:name<\/span><span class=\"p\">).<\/span><span class=\"nf\">value_or<\/span><span class=\"p\">(<\/span><span class=\"s2\">\"No state\"<\/span><span class=\"p\">)<\/span> <\/code><\/pre>\n<\/div>\n<\/div>\n<p>Il est \u00e9vident que, quoique l\u2019approche soit \u00e9l\u00e9gante \u2014 fini le <em>monkey patch<\/em> sur le moindre objet instanci\u00e9\u00a0\u2014, la syntaxe r\u00e9sultante dans notre exemple n\u2019est aucunement comparable \u00e0 la lisibilit\u00e9 du <em>safe navigation operator<\/em> (<code>&amp;.<\/code>).<\/p>\n<div class=\"language-ruby highlighter-rouge\">\n<div class=\"highlight\">\n<pre class=\"highlight\"><code><span class=\"n\">citizen<\/span><span class=\"o\">&amp;<\/span><span class=\"p\">.<\/span><span class=\"nf\">address<\/span><span class=\"o\">&amp;<\/span><span class=\"p\">.<\/span><span class=\"nf\">city<\/span><span class=\"o\">&amp;<\/span><span class=\"p\">.<\/span><span class=\"nf\">state<\/span><span class=\"o\">&amp;<\/span><span class=\"p\">.<\/span><span class=\"nf\">name<\/span> <span class=\"o\">||<\/span> <span class=\"s2\">\"No state\"<\/span> <\/code><\/pre>\n<\/div>\n<\/div>\n<p>Alors quoi\u00a0? C\u2019est int\u00e9ressant, mais inutile\u00a0? Eh bien non, pas si inutile que \u00e7a\u00a0! Si l\u2019on y regarde de plus pr\u00e8s, nous n\u2019avons utilis\u00e9 ici qu\u2019un sucre syntaxique de notre fameuse structure <code>Maybe<\/code>. En effet, la m\u00e9thode <code>maybe<\/code> fait deux choses\u00a0: elle applique (ou non) un bloc sur la valeur que contient notre instance de <code>Maybe<\/code> et retourne une nouvelle instance de cette m\u00eame classe dont la valeur est le r\u00e9sultat de cette op\u00e9ration. Ce qui se cache derri\u00e8re <code>maybe<\/code>, c\u2019est la m\u00e9thode <code>bind<\/code> que nous avons survol\u00e9e un peu plus t\u00f4t. L\u00e0 o\u00f9 le <em>safe navigation operator<\/em> nous cantonne \u00e0 l\u2019appel d\u2019une simple m\u00e9thode de l\u2019objet qui le pr\u00e9c\u00e8de, <code>bind<\/code> nous offre toute la puissance des blocs Ruby\u00a0!<\/p>\n<p>Imaginons que nous ayons besoin d\u2019associer une nouvelle adresse \u00e0 notre citoyen car celui-ci vient de d\u00e9m\u00e9nager. Et supposons que nous ayons deux m\u00e9thodes <code>find_citizen<\/code> et <code>find_address<\/code> qui nous retournent des instances de <code>Maybe<\/code>. Nous pourrions alors \u00e9crire ceci, sans nous soucier du fait que l\u2019on ait ou non trouv\u00e9 un citoyen et une adresse correspondant aux r\u00e9f\u00e9rences pass\u00e9es.<\/p>\n<div class=\"language-ruby highlighter-rouge\">\n<div class=\"highlight\">\n<pre class=\"highlight\"><code><span class=\"k\">def<\/span> <span class=\"nf\">move<\/span><span class=\"p\">(<\/span><span class=\"n\">params<\/span><span class=\"p\">)<\/span>   <span class=\"n\">find_citizen<\/span><span class=\"p\">(<\/span><span class=\"n\">params<\/span><span class=\"p\">[<\/span><span class=\"ss\">:citizen_id<\/span><span class=\"p\">]).<\/span><span class=\"nf\">bind<\/span> <span class=\"k\">do<\/span> <span class=\"o\">|<\/span><span class=\"n\">citizen<\/span><span class=\"o\">|<\/span>     <span class=\"n\">find_address<\/span><span class=\"p\">(<\/span><span class=\"n\">params<\/span><span class=\"p\">[<\/span><span class=\"ss\">:address_id<\/span><span class=\"p\">]).<\/span><span class=\"nf\">bind<\/span> <span class=\"k\">do<\/span> <span class=\"o\">|<\/span><span class=\"n\">address<\/span><span class=\"o\">|<\/span>       <span class=\"no\">Some<\/span><span class=\"p\">(<\/span><span class=\"n\">citizen<\/span><span class=\"p\">.<\/span><span class=\"nf\">update<\/span><span class=\"p\">(<\/span><span class=\"ss\">address_id: <\/span><span class=\"n\">address<\/span><span class=\"p\">.<\/span><span class=\"nf\">id<\/span><span class=\"p\">))<\/span>     <span class=\"k\">end<\/span>   <span class=\"k\">end<\/span> <span class=\"k\">end<\/span>  <span class=\"kp\">private<\/span>  <span class=\"k\">def<\/span> <span class=\"nf\">find_citizen<\/span><span class=\"p\">(<\/span><span class=\"n\">ref<\/span><span class=\"p\">)<\/span>   <span class=\"no\">Maybe<\/span><span class=\"p\">(<\/span><span class=\"no\">Citizen<\/span><span class=\"p\">.<\/span><span class=\"nf\">find<\/span><span class=\"p\">(<\/span><span class=\"n\">ref<\/span><span class=\"p\">))<\/span> <span class=\"k\">end<\/span>  <span class=\"k\">def<\/span> <span class=\"nf\">find_address<\/span><span class=\"p\">(<\/span><span class=\"n\">ref<\/span><span class=\"p\">)<\/span>   <span class=\"no\">Maybe<\/span><span class=\"p\">(<\/span><span class=\"no\">Address<\/span><span class=\"p\">.<\/span><span class=\"nf\">find<\/span><span class=\"p\">(<\/span><span class=\"n\">ref<\/span><span class=\"p\">))<\/span> <span class=\"k\">end<\/span> <\/code><\/pre>\n<\/div>\n<\/div>\n<p>Et pour remettre une couche de sucre syntaxique, et \u00e9viter la <em>pyramid of doom<\/em> que l\u2019on voit poindre, on peut utiliser la <em>do notation<\/em> :<\/p>\n<div class=\"language-ruby highlighter-rouge\">\n<div class=\"highlight\">\n<pre class=\"highlight\"><code><span class=\"k\">def<\/span> <span class=\"nf\">move<\/span><span class=\"p\">(<\/span><span class=\"n\">params<\/span><span class=\"p\">)<\/span>   <span class=\"n\">citizen<\/span> <span class=\"o\">=<\/span> <span class=\"k\">yield<\/span> <span class=\"n\">find_citizen<\/span><span class=\"p\">(<\/span><span class=\"n\">params<\/span><span class=\"p\">[<\/span><span class=\"ss\">:citizen_id<\/span><span class=\"p\">])<\/span>   <span class=\"n\">address<\/span> <span class=\"o\">=<\/span> <span class=\"k\">yield<\/span> <span class=\"n\">find_address<\/span><span class=\"p\">(<\/span><span class=\"n\">params<\/span><span class=\"p\">[<\/span><span class=\"ss\">:address_id<\/span><span class=\"p\">])<\/span>   <span class=\"no\">Some<\/span><span class=\"p\">(<\/span><span class=\"n\">citizen<\/span><span class=\"p\">.<\/span><span class=\"nf\">update<\/span><span class=\"p\">(<\/span><span class=\"ss\">address_id: <\/span><span class=\"n\">address<\/span><span class=\"p\">.<\/span><span class=\"nf\">id<\/span><span class=\"p\">))<\/span> <span class=\"k\">end<\/span> <\/code><\/pre>\n<\/div>\n<\/div>\n<p>\u00c0 pr\u00e9sent, l\u2019int\u00e9r\u00eat d\u2019une telle approche parait plus \u00e9vident. Le simple fait d\u2019\u00eatre certain de ce qu\u2019on manipule (ici des instances de <code>Maybe<\/code>), nous permet de faire abstraction des cas d\u2019erreur (la pr\u00e9sence d\u2019un <code>nil<\/code>) \u00e0 l\u2019\u00e9criture du code m\u00e9tier et d\u2019en d\u00e9l\u00e9guer leur gestion \u00e0 une structure \u00e9tudi\u00e9e pour absorber ce type d\u2019effet de bord. Notre code n\u2019est pas parasit\u00e9 par du code d\u00e9fensif, et notre intention s\u2019exprime clairement et sans entrave.<\/p>\n<p>Un petit mot sur la <em>do notation<\/em>. Elle n\u2019a rien de magique et ne sort pas de mon chapeau. Cette notation est <a href=\"https:\/\/en.wikibooks.org\/wiki\/Haskell\/do_notation\">inspir\u00e9e du langage Haskell<\/a> et, en Ruby, est notamment impl\u00e9ment\u00e9e par la gem <a href=\"https:\/\/dry-rb.org\/gems\/dry-monads\/\">dry-monad<\/a> dont est fortement inspir\u00e9 le code pr\u00e9sent\u00e9 dans cet article. Notons \u00e9galement que le mot cl\u00e9 <code>do<\/code> du langage Haskell a laiss\u00e9 place dans cette impl\u00e9mentation \u00e0 <code>yield<\/code>, mot cl\u00e9 du langage Ruby.<\/p>\n<h2 id=\"un-zeste-de-principes\">Un zeste de principes<\/h2>\n<p>Pour assurer le comportement qu\u2019on lui a observ\u00e9, <code>Maybe<\/code> se doit de respecter quelques principes\u00a0:<\/p>\n<ul>\n<li>\u00eatre capable de construire une nouvelle instance de <code>Maybe<\/code> \u00e0 partir d\u2019une valeur quelconque\u00a0;<\/li>\n<li>toujours retourner une instance de <code>Maybe<\/code> \u00e0 l\u2019appel de sa m\u00e9thode <code>maybe<\/code>, c\u2019est ce que l\u2019on nomme l\u2019identit\u00e9 et qui nous permet de chainer les appels\u00a0;<\/li>\n<li>enfin, retourner le m\u00eame r\u00e9sultat, peu importe la fa\u00e7on dont est embo\u00eet\u00e9 le cha\u00eenage des m\u00e9thodes.<\/li>\n<\/ul>\n<p>Ce dernier point correspond \u00e0 ce qu\u2019on nomme l\u2019associativit\u00e9. \u00c7a veut tout simplement dire que <code>(a + b) + c<\/code> est strictement \u00e9quivalent \u00e0 <code>a + (b + c)<\/code>. Pour le dire avec un exemple, les deux appels suivants retourneront le m\u00eame r\u00e9sultat.<\/p>\n<div class=\"language-ruby highlighter-rouge\">\n<div class=\"highlight\">\n<pre class=\"highlight\"><code><span class=\"n\">f<\/span> <span class=\"o\">=<\/span> <span class=\"o\">-&gt;<\/span><span class=\"p\">(<\/span><span class=\"n\">x<\/span><span class=\"p\">)<\/span> <span class=\"p\">{<\/span> <span class=\"n\">x<\/span> <span class=\"o\">+<\/span> <span class=\"mi\">5<\/span> <span class=\"p\">}<\/span> <span class=\"o\">=&gt;<\/span> <span class=\"c1\">#&lt;Proc:0x00007f03db2530d8: (lambda)&gt;<\/span> <span class=\"n\">g<\/span> <span class=\"o\">=<\/span> <span class=\"o\">-&gt;<\/span><span class=\"p\">(<\/span><span class=\"n\">x<\/span><span class=\"p\">)<\/span> <span class=\"p\">{<\/span> <span class=\"n\">x<\/span> <span class=\"o\">*<\/span> <span class=\"mi\">2<\/span> <span class=\"p\">}<\/span> <span class=\"o\">=&gt;<\/span> <span class=\"c1\">#&lt;Proc:0x00007f03db26a170: (lambda)&gt;<\/span> <span class=\"no\">Maybe<\/span><span class=\"p\">(<\/span><span class=\"mi\">10<\/span><span class=\"p\">).<\/span><span class=\"nf\">maybe<\/span><span class=\"p\">(<\/span><span class=\"n\">f<\/span><span class=\"p\">).<\/span><span class=\"nf\">maybe<\/span><span class=\"p\">(<\/span><span class=\"n\">g<\/span><span class=\"p\">)<\/span> <span class=\"o\">=&gt;<\/span> <span class=\"no\">Some<\/span><span class=\"p\">(<\/span><span class=\"mi\">30<\/span><span class=\"p\">)<\/span>  <span class=\"n\">h<\/span> <span class=\"o\">=<\/span> <span class=\"o\">-&gt;<\/span><span class=\"p\">(<\/span><span class=\"n\">x<\/span><span class=\"p\">)<\/span> <span class=\"p\">{<\/span> <span class=\"n\">g<\/span><span class=\"o\">.<\/span><span class=\"p\">(<\/span><span class=\"n\">f<\/span><span class=\"o\">.<\/span><span class=\"p\">(<\/span><span class=\"n\">x<\/span><span class=\"p\">))<\/span> <span class=\"p\">}<\/span> <span class=\"o\">=&gt;<\/span> <span class=\"c1\">#&lt;Proc:0x00007f03db2262b8: (lambda)&gt;<\/span> <span class=\"no\">Maybe<\/span><span class=\"p\">(<\/span><span class=\"mi\">10<\/span><span class=\"p\">).<\/span><span class=\"nf\">maybe<\/span><span class=\"p\">(<\/span><span class=\"n\">h<\/span><span class=\"p\">)<\/span> <span class=\"o\">=&gt;<\/span> <span class=\"no\">Some<\/span><span class=\"p\">(<\/span><span class=\"mi\">30<\/span><span class=\"p\">)<\/span> <\/code><\/pre>\n<\/div>\n<\/div>\n<p>Dans le premier cas, nous appliquons deux m\u00e9thodes en deux \u00e9tapes. Dans le second cas, nous composons d\u2019abord les m\u00e9thodes, puis nous appliquons le r\u00e9sultat. Les retours de ces appels doivent \u00eatre identiques.<\/p>\n<h2 id=\"une-myriade-de-dclinaisons\">Une myriade de d\u00e9clinaisons<\/h2>\n<p>En respectant ces m\u00eames principes d\u2019identit\u00e9 et d\u2019associativit\u00e9, nous sommes en mesure de r\u00e9pondre \u00e0 d\u2019autres probl\u00e9matiques communes comme la gestion des exceptions ou le traitement des messages asynchrones.<\/p>\n<p>\u00c0 l\u2019instar du couple <code>Some\/None<\/code> qui h\u00e9rite de <code>Maybe<\/code>, on peut impl\u00e9menter une gestion d\u2019exception via une structure <code>Try<\/code> qui se d\u00e9clinerait en deux variantes <code>Value\/Error<\/code>. Son usage ressemblerait \u00e0 ceci\u00a0:<\/p>\n<div class=\"language-ruby highlighter-rouge\">\n<div class=\"highlight\">\n<pre class=\"highlight\"><code><span class=\"no\">Try<\/span> <span class=\"p\">{<\/span> <span class=\"mi\">10<\/span> <span class=\"o\">\/<\/span> <span class=\"mi\">2<\/span> <span class=\"p\">}.<\/span><span class=\"nf\">fmap<\/span> <span class=\"p\">{<\/span> <span class=\"o\">|<\/span><span class=\"n\">x<\/span><span class=\"o\">|<\/span> <span class=\"n\">x<\/span> <span class=\"o\">*<\/span> <span class=\"mi\">3<\/span> <span class=\"p\">}<\/span> <span class=\"c1\"># =&gt; Try::Value(15)<\/span>  <span class=\"no\">Try<\/span> <span class=\"p\">{<\/span> <span class=\"mi\">10<\/span> <span class=\"o\">\/<\/span> <span class=\"mi\">0<\/span> <span class=\"p\">}.<\/span><span class=\"nf\">fmap<\/span> <span class=\"p\">{<\/span> <span class=\"o\">|<\/span><span class=\"n\">x<\/span><span class=\"o\">|<\/span> <span class=\"n\">x<\/span> <span class=\"o\">*<\/span> <span class=\"mi\">3<\/span> <span class=\"p\">}<\/span> <span class=\"c1\"># =&gt; Try::Error(ZeroDivisionError: divided by 0)<\/span> <\/code><\/pre>\n<\/div>\n<\/div>\n<p>Ici <code>fmap<\/code> est tout simplement l\u2019\u00e9quivalent de la m\u00e9thode <code>maybe<\/code> vue plus haut, et que nous aurions pu nommer <code>and_then<\/code> dans les deux cas si nous avions voulu \u00eatre plus g\u00e9n\u00e9rique.<\/p>\n<p>Autre exemple, que l\u2019on a d\u00e9j\u00e0 rencontr\u00e9 dans notre pr\u00e9c\u00e9dant article \u00ab\u00a0Rails n\u2019est pas simple\u00a0!\u00a0\u00bb, sans pour autant l\u2019avoir expliqu\u00e9, c\u2019est la structure de donn\u00e9es <code>Result<\/code> et ses deux d\u00e9clinaisons\u00a0<code>Success\/Failure<\/code>. Il s\u2019av\u00e8re en effet qu\u2019on se repose ici encore sur les m\u00eames principes qui r\u00e9gissent <code>Maybe<\/code> et <code>Try<\/code>. Ces structures portent un nom\u00a0: on les appelle des <strong>monades<\/strong>.<\/p>\n<p>Alors quel est le point commun dans les probl\u00e9matiques que tentent d\u2019assigner ces structures de donn\u00e9es\u00a0? <strong>Il s\u2019agit en r\u00e9alit\u00e9 de conserver la ma\u00eetrise sur d\u2019\u00e9ventuels effets de bord.<\/strong> Ainsi prot\u00e9g\u00e9, bien \u00e0 l\u2019abri sous notre parapluie, il nous est d\u00e8s lors possible de g\u00e9rer les impr\u00e9vus au moment o\u00f9 nous avons d\u00e9cid\u00e9 de nous en pr\u00e9occuper, plut\u00f4t qu\u2019\u00e0 l\u2019instant o\u00f9 ils nous tombent dessus.<\/p>\n<h2 id=\"ressources\">Ressources<\/h2>\n<ul>\n<li><a href=\"https:\/\/codon.com\/refactoring-ruby-with-monads\">Refactoring Ruby with monads<\/a> par Tom Stuart<\/li>\n<li><a href=\"https:\/\/dry-rb.org\/gems\/dry-monads\/\">DRY Monads<\/a>, une gem de la collection <a href=\"https:\/\/dry-rb.org\/\">dry-rb<\/a><\/li>\n<\/ul>\n","protected":false},"excerpt":{"rendered":"<p>Changer de point de vue pour solutionner simplement des probl\u00e9matiques complexes<\/p>\n","protected":false},"author":10,"featured_media":12524,"comment_status":"closed","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"content-type":"","inline_featured_image":false,"fifu_image_url":"","fifu_image_alt":"","footnotes":""},"categories":[34],"tags":[],"class_list":["post-7876","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-articles-techniques"],"acf":[],"yoast_head":"<!-- This site is optimized with the Yoast SEO plugin v28.9 - https:\/\/yoast.com\/product\/yoast-seo-wordpress\/ -->\n<title>Principe du parapluie - Ouidou<\/title>\n<meta name=\"description\" content=\"D\u00e9couvrez le principe du parapluie et comment il peut prot\u00e9ger vos projets des impr\u00e9vus gr\u00e2ce aux conseils de nos experts.\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/ouidou.fr\/blog\/articles-techniques\/principe-du-parapluie\" \/>\n<meta property=\"og:locale\" content=\"fr_FR\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Principe du parapluie - Ouidou\" \/>\n<meta property=\"og:description\" content=\"D\u00e9couvrez le principe du parapluie et comment il peut prot\u00e9ger vos projets des impr\u00e9vus gr\u00e2ce aux conseils de nos experts.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/ouidou.fr\/blog\/articles-techniques\/principe-du-parapluie\" \/>\n<meta property=\"og:site_name\" content=\"Ouidou\" \/>\n<meta property=\"article:published_time\" content=\"2021-01-14T23:00:00+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2024-11-07T10:20:45+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/ouidou.fr\/blog\/wp-content\/uploads\/2021\/01\/Principe-du-parapluie.png\" \/>\n\t<meta property=\"og:image:width\" content=\"1105\" \/>\n\t<meta property=\"og:image:height\" content=\"564\" \/>\n\t<meta property=\"og:image:type\" content=\"image\/png\" \/>\n<meta name=\"author\" content=\"Sara Lourties\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"\u00c9crit par\" \/>\n\t<meta name=\"twitter:data1\" content=\"Sara Lourties\" \/>\n\t<meta name=\"twitter:label2\" content=\"Dur\u00e9e de lecture estim\u00e9e\" \/>\n\t<meta name=\"twitter:data2\" content=\"10 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\\\/\\\/schema.org\",\"@graph\":[{\"@type\":\"Article\",\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/articles-techniques\\\/principe-du-parapluie#article\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/articles-techniques\\\/principe-du-parapluie\"},\"author\":{\"name\":\"Sara Lourties\",\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/#\\\/schema\\\/person\\\/e1d66085fb7c22ede319ce56adc373a4\"},\"headline\":\"Principe du parapluie\",\"datePublished\":\"2021-01-14T23:00:00+00:00\",\"dateModified\":\"2024-11-07T10:20:45+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/articles-techniques\\\/principe-du-parapluie\"},\"wordCount\":2096,\"publisher\":{\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/#organization\"},\"image\":{\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/articles-techniques\\\/principe-du-parapluie#primaryimage\"},\"thumbnailUrl\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/wp-content\\\/uploads\\\/2021\\\/01\\\/Principe-du-parapluie.png\",\"articleSection\":[\"Articles Techniques\"],\"inLanguage\":\"fr-FR\"},{\"@type\":\"WebPage\",\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/articles-techniques\\\/principe-du-parapluie\",\"url\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/articles-techniques\\\/principe-du-parapluie\",\"name\":\"Principe du parapluie - Ouidou\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/articles-techniques\\\/principe-du-parapluie#primaryimage\"},\"image\":{\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/articles-techniques\\\/principe-du-parapluie#primaryimage\"},\"thumbnailUrl\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/wp-content\\\/uploads\\\/2021\\\/01\\\/Principe-du-parapluie.png\",\"datePublished\":\"2021-01-14T23:00:00+00:00\",\"dateModified\":\"2024-11-07T10:20:45+00:00\",\"description\":\"D\u00e9couvrez le principe du parapluie et comment il peut prot\u00e9ger vos projets des impr\u00e9vus gr\u00e2ce aux conseils de nos experts.\",\"breadcrumb\":{\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/articles-techniques\\\/principe-du-parapluie#breadcrumb\"},\"inLanguage\":\"fr-FR\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\\\/\\\/ouidou.fr\\\/blog\\\/articles-techniques\\\/principe-du-parapluie\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"fr-FR\",\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/articles-techniques\\\/principe-du-parapluie#primaryimage\",\"url\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/wp-content\\\/uploads\\\/2021\\\/01\\\/Principe-du-parapluie.png\",\"contentUrl\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/wp-content\\\/uploads\\\/2021\\\/01\\\/Principe-du-parapluie.png\",\"width\":1105,\"height\":564,\"caption\":\"Principe du parapluie - visuel article technique\"},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/articles-techniques\\\/principe-du-parapluie#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Accueil\",\"item\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Principe du parapluie\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/#website\",\"url\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/\",\"name\":\"Blog Ouidou\",\"description\":\"Conseil et expertise en technologies\",\"publisher\":{\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/#organization\"},\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"fr-FR\"},{\"@type\":\"Organization\",\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/#organization\",\"name\":\"Ouidou\",\"url\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"fr-FR\",\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/#\\\/schema\\\/logo\\\/image\\\/\",\"url\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/wp-content\\\/uploads\\\/2022\\\/04\\\/image_2022-04-13_150237378.png\",\"contentUrl\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/wp-content\\\/uploads\\\/2022\\\/04\\\/image_2022-04-13_150237378.png\",\"width\":180,\"height\":180,\"caption\":\"Ouidou\"},\"image\":{\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/#\\\/schema\\\/logo\\\/image\\\/\"}},{\"@type\":\"Person\",\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/#\\\/schema\\\/person\\\/e1d66085fb7c22ede319ce56adc373a4\",\"name\":\"Sara Lourties\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"fr-FR\",\"@id\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/b2ef32f9fc1e16168b39587a2ec1dafedc70a9d41fa1b4a930ec7744b3e35ec7?s=96&d=mm&r=g\",\"url\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/b2ef32f9fc1e16168b39587a2ec1dafedc70a9d41fa1b4a930ec7744b3e35ec7?s=96&d=mm&r=g\",\"contentUrl\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/b2ef32f9fc1e16168b39587a2ec1dafedc70a9d41fa1b4a930ec7744b3e35ec7?s=96&d=mm&r=g\",\"caption\":\"Sara Lourties\"}}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"Principe du parapluie - Ouidou","description":"D\u00e9couvrez le principe du parapluie et comment il peut prot\u00e9ger vos projets des impr\u00e9vus gr\u00e2ce aux conseils de nos experts.","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/ouidou.fr\/blog\/articles-techniques\/principe-du-parapluie","og_locale":"fr_FR","og_type":"article","og_title":"Principe du parapluie - Ouidou","og_description":"D\u00e9couvrez le principe du parapluie et comment il peut prot\u00e9ger vos projets des impr\u00e9vus gr\u00e2ce aux conseils de nos experts.","og_url":"https:\/\/ouidou.fr\/blog\/articles-techniques\/principe-du-parapluie","og_site_name":"Ouidou","article_published_time":"2021-01-14T23:00:00+00:00","article_modified_time":"2024-11-07T10:20:45+00:00","og_image":[{"width":1105,"height":564,"url":"https:\/\/ouidou.fr\/blog\/wp-content\/uploads\/2021\/01\/Principe-du-parapluie.png","type":"image\/png"}],"author":"Sara Lourties","twitter_card":"summary_large_image","twitter_misc":{"\u00c9crit par":"Sara Lourties","Dur\u00e9e de lecture estim\u00e9e":"10 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/ouidou.fr\/blog\/articles-techniques\/principe-du-parapluie#article","isPartOf":{"@id":"https:\/\/ouidou.fr\/blog\/articles-techniques\/principe-du-parapluie"},"author":{"name":"Sara Lourties","@id":"https:\/\/ouidou.fr\/blog\/#\/schema\/person\/e1d66085fb7c22ede319ce56adc373a4"},"headline":"Principe du parapluie","datePublished":"2021-01-14T23:00:00+00:00","dateModified":"2024-11-07T10:20:45+00:00","mainEntityOfPage":{"@id":"https:\/\/ouidou.fr\/blog\/articles-techniques\/principe-du-parapluie"},"wordCount":2096,"publisher":{"@id":"https:\/\/ouidou.fr\/blog\/#organization"},"image":{"@id":"https:\/\/ouidou.fr\/blog\/articles-techniques\/principe-du-parapluie#primaryimage"},"thumbnailUrl":"https:\/\/ouidou.fr\/blog\/wp-content\/uploads\/2021\/01\/Principe-du-parapluie.png","articleSection":["Articles Techniques"],"inLanguage":"fr-FR"},{"@type":"WebPage","@id":"https:\/\/ouidou.fr\/blog\/articles-techniques\/principe-du-parapluie","url":"https:\/\/ouidou.fr\/blog\/articles-techniques\/principe-du-parapluie","name":"Principe du parapluie - Ouidou","isPartOf":{"@id":"https:\/\/ouidou.fr\/blog\/#website"},"primaryImageOfPage":{"@id":"https:\/\/ouidou.fr\/blog\/articles-techniques\/principe-du-parapluie#primaryimage"},"image":{"@id":"https:\/\/ouidou.fr\/blog\/articles-techniques\/principe-du-parapluie#primaryimage"},"thumbnailUrl":"https:\/\/ouidou.fr\/blog\/wp-content\/uploads\/2021\/01\/Principe-du-parapluie.png","datePublished":"2021-01-14T23:00:00+00:00","dateModified":"2024-11-07T10:20:45+00:00","description":"D\u00e9couvrez le principe du parapluie et comment il peut prot\u00e9ger vos projets des impr\u00e9vus gr\u00e2ce aux conseils de nos experts.","breadcrumb":{"@id":"https:\/\/ouidou.fr\/blog\/articles-techniques\/principe-du-parapluie#breadcrumb"},"inLanguage":"fr-FR","potentialAction":[{"@type":"ReadAction","target":["https:\/\/ouidou.fr\/blog\/articles-techniques\/principe-du-parapluie"]}]},{"@type":"ImageObject","inLanguage":"fr-FR","@id":"https:\/\/ouidou.fr\/blog\/articles-techniques\/principe-du-parapluie#primaryimage","url":"https:\/\/ouidou.fr\/blog\/wp-content\/uploads\/2021\/01\/Principe-du-parapluie.png","contentUrl":"https:\/\/ouidou.fr\/blog\/wp-content\/uploads\/2021\/01\/Principe-du-parapluie.png","width":1105,"height":564,"caption":"Principe du parapluie - visuel article technique"},{"@type":"BreadcrumbList","@id":"https:\/\/ouidou.fr\/blog\/articles-techniques\/principe-du-parapluie#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Accueil","item":"https:\/\/ouidou.fr\/blog\/"},{"@type":"ListItem","position":2,"name":"Principe du parapluie"}]},{"@type":"WebSite","@id":"https:\/\/ouidou.fr\/blog\/#website","url":"https:\/\/ouidou.fr\/blog\/","name":"Blog Ouidou","description":"Conseil et expertise en technologies","publisher":{"@id":"https:\/\/ouidou.fr\/blog\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/ouidou.fr\/blog\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"fr-FR"},{"@type":"Organization","@id":"https:\/\/ouidou.fr\/blog\/#organization","name":"Ouidou","url":"https:\/\/ouidou.fr\/blog\/","logo":{"@type":"ImageObject","inLanguage":"fr-FR","@id":"https:\/\/ouidou.fr\/blog\/#\/schema\/logo\/image\/","url":"https:\/\/ouidou.fr\/blog\/wp-content\/uploads\/2022\/04\/image_2022-04-13_150237378.png","contentUrl":"https:\/\/ouidou.fr\/blog\/wp-content\/uploads\/2022\/04\/image_2022-04-13_150237378.png","width":180,"height":180,"caption":"Ouidou"},"image":{"@id":"https:\/\/ouidou.fr\/blog\/#\/schema\/logo\/image\/"}},{"@type":"Person","@id":"https:\/\/ouidou.fr\/blog\/#\/schema\/person\/e1d66085fb7c22ede319ce56adc373a4","name":"Sara Lourties","image":{"@type":"ImageObject","inLanguage":"fr-FR","@id":"https:\/\/secure.gravatar.com\/avatar\/b2ef32f9fc1e16168b39587a2ec1dafedc70a9d41fa1b4a930ec7744b3e35ec7?s=96&d=mm&r=g","url":"https:\/\/secure.gravatar.com\/avatar\/b2ef32f9fc1e16168b39587a2ec1dafedc70a9d41fa1b4a930ec7744b3e35ec7?s=96&d=mm&r=g","contentUrl":"https:\/\/secure.gravatar.com\/avatar\/b2ef32f9fc1e16168b39587a2ec1dafedc70a9d41fa1b4a930ec7744b3e35ec7?s=96&d=mm&r=g","caption":"Sara Lourties"}}]}},"_links":{"self":[{"href":"https:\/\/ouidou.fr\/blog\/wp-json\/wp\/v2\/posts\/7876","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/ouidou.fr\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/ouidou.fr\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/ouidou.fr\/blog\/wp-json\/wp\/v2\/users\/10"}],"replies":[{"embeddable":true,"href":"https:\/\/ouidou.fr\/blog\/wp-json\/wp\/v2\/comments?post=7876"}],"version-history":[{"count":4,"href":"https:\/\/ouidou.fr\/blog\/wp-json\/wp\/v2\/posts\/7876\/revisions"}],"predecessor-version":[{"id":16636,"href":"https:\/\/ouidou.fr\/blog\/wp-json\/wp\/v2\/posts\/7876\/revisions\/16636"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/ouidou.fr\/blog\/wp-json\/wp\/v2\/media\/12524"}],"wp:attachment":[{"href":"https:\/\/ouidou.fr\/blog\/wp-json\/wp\/v2\/media?parent=7876"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/ouidou.fr\/blog\/wp-json\/wp\/v2\/categories?post=7876"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/ouidou.fr\/blog\/wp-json\/wp\/v2\/tags?post=7876"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}