slides/lecture12.html

<!DOCTYPE html>
<!--
  Copyright 2010 Google Inc.

  Licensed under the Apache License, Version 2.0 (the "License");
  you may not use this file except in compliance with the License.
  You may obtain a copy of the License at

     http://www.apache.org/licenses/LICENSE-2.0

  Unless required by applicable law or agreed to in writing, software
  distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions and
  limitations under the License.

  Original slides: Marcin Wichary (mwichary@google.com)
  Modifications: Ernest Delgado (ernestd@google.com)
                 Alex Russell (slightlyoff@chromium.org)

  landslide modifications: Adam Zapletal (adamzap@gmail.com)
                           Nicolas Perriault (nperriault@gmail.com)
-->
<html>
<head>
    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
    <meta http-equiv="X-UA-Compatible" content="chrome=1">
    <title>Lecture 12: Applicatives</title>
    <!-- Styles -->
    
    <link rel="stylesheet" media="print" href="theme/css/print.css">
    <link rel="stylesheet" media="screen, projection" href="theme/css/screen.css">
    
    
    <!-- /Styles -->
    <!-- Javascripts -->
    
    <script type="text/javascript" src="theme/js/slides.js"></script>
    
    
    <!-- /Javascripts -->
    <script type="text/x-mathjax-config">
      MathJax.Hub.Config({
        extensions: ["tex2jax.js"],
        jax: ["input/TeX", "output/HTML-CSS"],
        tex2jax: {
          inlineMath: [ ['$','$'], ["\\(","\\)"] ],
          displayMath: [ ['$$','$$'], ["\\[","\\]"] ],
          processEscapes: true
        },
        "HTML-CSS": { availableFonts: ["TeX"] }
      });
    </script>
    <script type="text/javascript"
        src="http://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML">
    </script>
</head>
<body style="!important;">
  <div id="blank"></div>
  <div class="presentation">
    <div id="current_presenter_notes">
      <div id="presenter_note"></div>
    </div>
    <div class="slides">
      
      <!-- slide source: lecture12.md -->
      <div class="slide-wrapper">
        <div class="slide">
          <div class="inner">
            
            <header><h1>Lecture 12: Applicatives</h1></header>
            
            
          </div>
          <div class="presenter_notes">
            <header><h1>Presenter Notes</h1></header>
            <section>
            
            </section>
          </div>


          <footer>
            
            <aside class="source">
              Source: <a href="lecture12.md">lecture12.md</a>
            </aside>
            
            <aside class="page_number">
              1/63
            </aside>

          </footer>
        </div>
      </div>
      
      <!-- slide source: lecture12.md -->
      <div class="slide-wrapper">
        <div class="slide">
          <div class="inner">
            
            
            <section><p><code>Functor</code> gives us a way to transform any values embedded in structure.
<br />
<br />
<code>Applicative</code> is a monoidal functor. It gives us a way to transform any values contained within a structure using a function that is also embedded in the same structure.
<br />
<br />
This means that each application produces the effect of adding structure which is then combined using the monoid laws.</p></section>
            
          </div>
          <div class="presenter_notes">
            <header><h1>Presenter Notes</h1></header>
            <section>
            
            </section>
          </div>


          <footer>
            
            <aside class="source">
              Source: <a href="lecture12.md">lecture12.md</a>
            </aside>
            
            <aside class="page_number">
              2/63
            </aside>

          </footer>
        </div>
      </div>
      
      <!-- slide source: lecture12.md -->
      <div class="slide-wrapper">
        <div class="slide">
          <div class="inner">
            
            <header><h1>Apply</h1></header>
            
            
            <section><p><code>Apply</code> extends the <code>Functor</code> type class (which features the familiar <code>map</code> function) with a new function <code>ap</code>.
<br />
<br />
The <code>ap</code> function is similar to map in that we are transforming a value in a context (a context being the <code>F</code> in <code>F[A]</code>; a context can be <code>Option</code>, <code>List</code> or <code>Future</code> for example).
<br />
<br />
However, the difference between <code>ap</code> and <code>map</code> is that for <code>ap</code> the function that takes care of the transformation is of type <code>F[A =&gt; B]</code>, whereas for <code>map</code> it is <code>A =&gt; B</code></p></section>
            
          </div>
          <div class="presenter_notes">
            <header><h1>Presenter Notes</h1></header>
            <section>
            
            </section>
          </div>


          <footer>
            
            <aside class="source">
              Source: <a href="lecture12.md">lecture12.md</a>
            </aside>
            
            <aside class="page_number">
              3/63
            </aside>

          </footer>
        </div>
      </div>
      
      <!-- slide source: lecture12.md -->
      <div class="slide-wrapper">
        <div class="slide has_code">
          <div class="inner">
            
            
            <section><div class="highlight"><pre><span></span><span class="k">import</span> <span class="nn">cats._</span>
<span class="k">val</span> <span class="n">double</span><span class="k">:</span> <span class="kt">Int</span> <span class="o">=&gt;</span> <span class="nc">Int</span> <span class="k">=</span> <span class="k">_</span> <span class="o">*</span> <span class="mi">2</span>
<span class="nc">Apply</span><span class="o">[</span><span class="kt">Option</span><span class="o">].</span><span class="n">ap</span><span class="o">(</span><span class="nc">Some</span><span class="o">(</span><span class="n">double</span><span class="o">))(</span><span class="nc">Some</span><span class="o">(</span><span class="mi">1</span><span class="o">))</span>
<span class="c1">//res8: Option[Int] = Some(2)</span>
<span class="nc">Apply</span><span class="o">[</span><span class="kt">Option</span><span class="o">].</span><span class="n">ap</span><span class="o">(</span><span class="nc">Some</span><span class="o">(</span><span class="n">double</span><span class="o">))(</span><span class="nc">None</span><span class="o">)</span>
<span class="c1">//res9: Option[Int] = None</span>
<span class="nc">Apply</span><span class="o">[</span><span class="kt">Option</span><span class="o">].</span><span class="n">ap</span><span class="o">(</span><span class="nc">None</span><span class="o">)(</span><span class="nc">Some</span><span class="o">(</span><span class="mi">1</span><span class="o">))</span>
<span class="c1">//res10: Option[Nothing] = None</span>
</pre></div>
</section>
            
          </div>
          <div class="presenter_notes">
            <header><h1>Presenter Notes</h1></header>
            <section>
            
            </section>
          </div>


          <footer>
            
            <aside class="source">
              Source: <a href="lecture12.md">lecture12.md</a>
            </aside>
            
            <aside class="page_number">
              4/63
            </aside>

          </footer>
        </div>
      </div>
      
      <!-- slide source: lecture12.md -->
      <div class="slide-wrapper">
        <div class="slide">
          <div class="inner">
            
            <header><h1>Applicative</h1></header>
            
            
            <section><p>Cats models applicatives using two type classes.
<br />
<br />
The first, <code>Apply</code> extends <code>Cartesian</code> and <code>Functor</code>, adding an <code>ap</code> method that applies a parameter to a function within a context.
<br />
<br />
The second, <code>Applicative</code> extends <code>Apply</code>, adding the <code>pure</code> method.</p></section>
            
          </div>
          <div class="presenter_notes">
            <header><h1>Presenter Notes</h1></header>
            <section>
            
            </section>
          </div>


          <footer>
            
            <aside class="source">
              Source: <a href="lecture12.md">lecture12.md</a>
            </aside>
            
            <aside class="page_number">
              5/63
            </aside>

          </footer>
        </div>
      </div>
      
      <!-- slide source: lecture12.md -->
      <div class="slide-wrapper">
        <div class="slide has_code">
          <div class="inner">
            
            
            <section><div class="highlight"><pre><span></span><span class="k">trait</span> <span class="nc">Apply</span><span class="o">[</span><span class="kt">F</span><span class="o">[</span><span class="k">_</span><span class="o">]]</span> <span class="nc">extends</span> <span class="nc">Cartesian</span><span class="o">[</span><span class="kt">F</span><span class="o">]</span> <span class="k">with</span> <span class="nc">Functor</span><span class="o">[</span><span class="kt">F</span><span class="o">]</span> <span class="o">{</span>
  <span class="k">def</span> <span class="n">ap</span><span class="o">[</span><span class="kt">A</span>, <span class="kt">B</span><span class="o">](</span><span class="n">ff</span><span class="k">:</span> <span class="kt">F</span><span class="o">[</span><span class="kt">A</span> <span class="k">=&gt;</span> <span class="kt">B</span><span class="o">])(</span><span class="n">fa</span><span class="k">:</span> <span class="kt">F</span><span class="o">[</span><span class="kt">A</span><span class="o">])</span><span class="k">:</span> <span class="kt">F</span><span class="o">[</span><span class="kt">B</span><span class="o">]</span>
  <span class="k">def</span> <span class="n">product</span><span class="o">[</span><span class="kt">A</span>, <span class="kt">B</span><span class="o">](</span><span class="n">fa</span><span class="k">:</span> <span class="kt">F</span><span class="o">[</span><span class="kt">A</span><span class="o">],</span> <span class="n">fb</span><span class="k">:</span> <span class="kt">F</span><span class="o">[</span><span class="kt">B</span><span class="o">])</span><span class="k">:</span> <span class="kt">F</span><span class="o">[(</span><span class="kt">A</span>, <span class="kt">B</span><span class="o">)]</span> <span class="k">=</span>
    <span class="n">ap</span><span class="o">(</span><span class="n">map</span><span class="o">(</span><span class="n">fa</span><span class="o">)(</span><span class="n">a</span> <span class="k">=&gt;</span> <span class="o">(</span><span class="n">b</span><span class="k">:</span> <span class="kt">B</span><span class="o">)</span> <span class="k">=&gt;</span> <span class="o">(</span><span class="n">a</span><span class="o">,</span> <span class="n">b</span><span class="o">)))(</span><span class="n">fb</span><span class="o">)</span>
<span class="o">}</span>
<span class="k">trait</span> <span class="nc">Applicative</span><span class="o">[</span><span class="kt">F</span><span class="o">[</span><span class="k">_</span><span class="o">]]</span> <span class="nc">extends</span> <span class="nc">Apply</span><span class="o">[</span><span class="kt">F</span><span class="o">]</span> <span class="o">{</span>
  <span class="k">def</span> <span class="n">pure</span><span class="o">[</span><span class="kt">A</span><span class="o">](</span><span class="n">a</span><span class="k">:</span> <span class="kt">A</span><span class="o">)</span><span class="k">:</span> <span class="kt">F</span><span class="o">[</span><span class="kt">A</span><span class="o">]</span>
<span class="o">}</span>
</pre></div>
</section>
            
          </div>
          <div class="presenter_notes">
            <header><h1>Presenter Notes</h1></header>
            <section>
            
            </section>
          </div>


          <footer>
            
            <aside class="source">
              Source: <a href="lecture12.md">lecture12.md</a>
            </aside>
            
            <aside class="page_number">
              6/63
            </aside>

          </footer>
        </div>
      </div>
      
      <!-- slide source: lecture12.md -->
      <div class="slide-wrapper">
        <div class="slide">
          <div class="inner">
            
            
            <section><p>The <code>pure</code> method in <code>Applicative</code> is the same <code>pure</code> we saw in <code>Monad</code>.
<br />
<br />
It constructs a new applicative instance from an unwrapped value.
<br />
<br />
In this sense, <code>Applicative</code> is related to <code>Apply</code> as <code>Monoid</code> is related to <code>Semigroup</code>.</p></section>
            
          </div>
          <div class="presenter_notes">
            <header><h1>Presenter Notes</h1></header>
            <section>
            
            </section>
          </div>


          <footer>
            
            <aside class="source">
              Source: <a href="lecture12.md">lecture12.md</a>
            </aside>
            
            <aside class="page_number">
              7/63
            </aside>

          </footer>
        </div>
      </div>
      
      <!-- slide source: lecture12.md -->
      <div class="slide-wrapper">
        <div class="slide">
          <div class="inner">
            
            
            <section><p>Note also that <code>product</code> is a derived combinator (i.e. it is defined in terms of <code>ap</code> and <code>map</code>).
<br />
<br />
There is an equivalence between <code>ap</code>, <code>map</code>, and <code>product</code> that allows any one of them to be defined in terms of the other two.</p>
<ul>
<li>map over F[A] to produce a value of type F[B =&gt; (A, B)];</li>
<li>apply F[B] as a parameter to F[B=&gt;(A,B)] to get a result of type F[(A,B)].</li>
</ul></section>
            
          </div>
          <div class="presenter_notes">
            <header><h1>Presenter Notes</h1></header>
            <section>
            
            </section>
          </div>


          <footer>
            
            <aside class="source">
              Source: <a href="lecture12.md">lecture12.md</a>
            </aside>
            
            <aside class="page_number">
              8/63
            </aside>

          </footer>
        </div>
      </div>
      
      <!-- slide source: lecture12.md -->
      <div class="slide-wrapper">
        <div class="slide">
          <div class="inner">
            
            
            <section><p>By defining one of these three methods in terms of the other two, we ensure that the derived definitions are consistent for all implementations of <code>Apply</code>.
<br />
<br />
This is somewhat similar to the relationship between <code>compose</code>, <code>join</code> and <code>flatMap</code> for monads (i.e. if you are given <code>pure</code>, <code>map</code> and any of the above you can implement the other two).</p></section>
            
          </div>
          <div class="presenter_notes">
            <header><h1>Presenter Notes</h1></header>
            <section>
            
            </section>
          </div>


          <footer>
            
            <aside class="source">
              Source: <a href="lecture12.md">lecture12.md</a>
            </aside>
            
            <aside class="page_number">
              9/63
            </aside>

          </footer>
        </div>
      </div>
      
      <!-- slide source: lecture12.md -->
      <div class="slide-wrapper">
        <div class="slide has_code">
          <div class="inner">
            
            
            <section><div class="highlight"><pre><span></span><span class="k">trait</span> <span class="nc">Applicative</span><span class="o">[</span><span class="kt">F</span><span class="o">[</span><span class="k">_</span><span class="o">]]</span> <span class="nc">extends</span> <span class="nc">Apply</span><span class="o">[</span><span class="kt">F</span><span class="o">]</span> <span class="o">{</span>
  <span class="k">def</span> <span class="n">pure</span><span class="o">[</span><span class="kt">A</span><span class="o">](</span><span class="n">a</span><span class="k">:</span> <span class="kt">A</span><span class="o">)</span><span class="k">:</span> <span class="kt">F</span><span class="o">[</span><span class="kt">A</span><span class="o">]</span>
  <span class="k">override</span> <span class="k">def</span> <span class="n">map</span><span class="o">[</span><span class="kt">A</span>, <span class="kt">B</span><span class="o">](</span><span class="n">fa</span><span class="k">:</span> <span class="kt">F</span><span class="o">[</span><span class="kt">A</span><span class="o">])(</span><span class="n">f</span><span class="k">:</span> <span class="kt">A</span> <span class="o">=&gt;</span> <span class="n">B</span><span class="o">)</span><span class="k">:</span> <span class="kt">F</span><span class="o">[</span><span class="kt">B</span><span class="o">]</span> <span class="k">=</span>
    <span class="n">ap</span><span class="o">(</span><span class="n">pure</span><span class="o">(</span><span class="n">f</span><span class="o">))(</span><span class="n">fa</span><span class="o">)</span>
  <span class="k">def</span> <span class="n">map2</span><span class="o">[</span><span class="kt">A</span>,<span class="kt">B</span>,<span class="kt">C</span><span class="o">](</span><span class="n">fa</span><span class="k">:</span> <span class="kt">F</span><span class="o">[</span><span class="kt">A</span><span class="o">],</span> <span class="n">fb</span><span class="k">:</span> <span class="kt">F</span><span class="o">[</span><span class="kt">B</span><span class="o">])(</span><span class="n">f</span><span class="k">:</span> <span class="o">(</span><span class="kt">A</span><span class="o">,</span> <span class="kt">B</span><span class="o">)</span> <span class="k">=&gt;</span> <span class="n">C</span><span class="o">)</span><span class="k">:</span> <span class="kt">F</span><span class="o">[</span><span class="kt">C</span><span class="o">]</span> <span class="k">=</span>
    <span class="n">ap</span><span class="o">(</span><span class="n">map</span><span class="o">(</span><span class="n">fa</span><span class="o">)(</span><span class="n">f</span><span class="o">.</span><span class="n">curried</span><span class="o">))(</span><span class="n">fb</span><span class="o">)</span>
  <span class="k">override</span> <span class="k">def</span> <span class="n">product</span><span class="o">[</span><span class="kt">A</span>, <span class="kt">B</span><span class="o">](</span><span class="n">fa</span><span class="k">:</span> <span class="kt">F</span><span class="o">[</span><span class="kt">A</span><span class="o">],</span> <span class="n">fb</span><span class="k">:</span> <span class="kt">F</span><span class="o">[</span><span class="kt">B</span><span class="o">])</span><span class="k">:</span> <span class="kt">F</span><span class="o">[(</span><span class="kt">A</span>, <span class="kt">B</span><span class="o">)]</span> <span class="k">=</span>
    <span class="n">map2</span><span class="o">(</span><span class="n">fa</span><span class="o">,</span> <span class="n">fb</span><span class="o">)((</span><span class="k">_</span><span class="o">,</span><span class="k">_</span><span class="o">))</span>
<span class="o">}</span>
</pre></div>
</section>
            
          </div>
          <div class="presenter_notes">
            <header><h1>Presenter Notes</h1></header>
            <section>
            
            </section>
          </div>


          <footer>
            
            <aside class="source">
              Source: <a href="lecture12.md">lecture12.md</a>
            </aside>
            
            <aside class="page_number">
              10/63
            </aside>

          </footer>
        </div>
      </div>
      
      <!-- slide source: lecture12.md -->
      <div class="slide-wrapper">
        <div class="slide">
          <div class="inner">
            
            
            <section><p><code>map2</code> is implemented by first currying <code>f</code> so we get a function of type <code>A =&gt; B =&gt; C</code>.
<br />
<br />
This is a function that takes <code>A</code> and returns another function of type <code>B =&gt; C</code>.
<br />
<br />
So if we map <code>f.curried</code> over an <code>F[A]</code>, we get <code>F[B =&gt; C]</code>.
<br />
<br />
Passing that to <code>apply</code> along with the <code>F[B]</code> will give us the desired <code>F[C]</code>.</p></section>
            
          </div>
          <div class="presenter_notes">
            <header><h1>Presenter Notes</h1></header>
            <section>
            
            </section>
          </div>


          <footer>
            
            <aside class="source">
              Source: <a href="lecture12.md">lecture12.md</a>
            </aside>
            
            <aside class="page_number">
              11/63
            </aside>

          </footer>
        </div>
      </div>
      
      <!-- slide source: lecture12.md -->
      <div class="slide-wrapper">
        <div class="slide has_code">
          <div class="inner">
            
            
            <section><p>Given <code>map</code> and <code>product</code> we could create a <code>map2</code> and use it to implement our <code>ap</code>:</p>
<div class="highlight"><pre><span></span><span class="k">trait</span> <span class="nc">Applicative</span><span class="o">[</span><span class="kt">F</span><span class="o">[</span><span class="k">_</span><span class="o">]]</span> <span class="nc">extends</span> <span class="nc">Apply</span><span class="o">[</span><span class="kt">F</span><span class="o">]</span> <span class="o">{</span>
  <span class="k">def</span> <span class="n">pure</span><span class="o">[</span><span class="kt">A</span><span class="o">](</span><span class="n">a</span><span class="k">:</span> <span class="kt">A</span><span class="o">)</span><span class="k">:</span> <span class="kt">F</span><span class="o">[</span><span class="kt">A</span><span class="o">]</span>
  <span class="k">def</span> <span class="n">product</span><span class="o">[</span><span class="kt">A</span>, <span class="kt">B</span><span class="o">](</span><span class="n">fa</span><span class="k">:</span> <span class="kt">F</span><span class="o">[</span><span class="kt">A</span><span class="o">],</span> <span class="n">fb</span><span class="k">:</span> <span class="kt">F</span><span class="o">[</span><span class="kt">B</span><span class="o">])</span><span class="k">:</span> <span class="kt">F</span><span class="o">[(</span><span class="kt">A</span>, <span class="kt">B</span><span class="o">)]</span>
  <span class="k">def</span> <span class="n">map2</span><span class="o">[</span><span class="kt">A</span>,<span class="kt">B</span>,<span class="kt">C</span><span class="o">](</span><span class="n">fa</span><span class="k">:</span> <span class="kt">F</span><span class="o">[</span><span class="kt">A</span><span class="o">],</span> <span class="n">fb</span><span class="k">:</span> <span class="kt">F</span><span class="o">[</span><span class="kt">B</span><span class="o">])(</span><span class="n">f</span><span class="k">:</span> <span class="o">(</span><span class="kt">A</span><span class="o">,</span> <span class="kt">B</span><span class="o">)</span> <span class="k">=&gt;</span> <span class="n">C</span><span class="o">)</span><span class="k">:</span> <span class="kt">F</span><span class="o">[</span><span class="kt">C</span><span class="o">]</span> <span class="k">=</span>
    <span class="n">map</span><span class="o">(</span><span class="n">product</span><span class="o">(</span><span class="n">fa</span><span class="o">,</span> <span class="n">fb</span><span class="o">))</span> <span class="o">{</span> <span class="k">case</span> <span class="o">(</span><span class="n">a</span><span class="o">,</span> <span class="n">b</span><span class="o">)</span> <span class="k">=&gt;</span> <span class="n">f</span><span class="o">(</span><span class="n">a</span><span class="o">,</span> <span class="n">b</span><span class="o">)</span> <span class="o">}</span>
  <span class="k">override</span> <span class="k">def</span> <span class="n">ap</span><span class="o">[</span><span class="kt">A</span>,<span class="kt">B</span><span class="o">](</span><span class="n">fab</span><span class="k">:</span> <span class="kt">F</span><span class="o">[</span><span class="kt">A</span> <span class="k">=&gt;</span> <span class="kt">B</span><span class="o">])(</span><span class="n">fa</span><span class="k">:</span> <span class="kt">F</span><span class="o">[</span><span class="kt">A</span><span class="o">])</span><span class="k">:</span> <span class="kt">F</span><span class="o">[</span><span class="kt">B</span><span class="o">]</span> <span class="k">=</span>
    <span class="n">map2</span><span class="o">(</span><span class="n">fab</span><span class="o">,</span> <span class="n">fa</span><span class="o">)(</span><span class="k">_</span><span class="o">(</span><span class="k">_</span><span class="o">))</span>
<span class="o">}</span>
</pre></div>
</section>
            
          </div>
          <div class="presenter_notes">
            <header><h1>Presenter Notes</h1></header>
            <section>
            
            </section>
          </div>


          <footer>
            
            <aside class="source">
              Source: <a href="lecture12.md">lecture12.md</a>
            </aside>
            
            <aside class="page_number">
              12/63
            </aside>

          </footer>
        </div>
      </div>
      
      <!-- slide source: lecture12.md -->
      <div class="slide-wrapper">
        <div class="slide">
          <div class="inner">
            
            
            <section><p>We simply use <code>map2</code> to lift a function into <code>F</code> so we can apply it to both <code>fab</code> and <code>fa</code>.
<br />
<br />
The function being lifted here is <code>_(_)</code>, which is the same as the lambda notation <code>(f, x) =&gt; f(x)</code>.
<br />
<br />
That is, it's a function that takes a function <code>f</code> and an argument <code>x</code>, and simply applies <code>f</code> to <code>x</code>.</p></section>
            
          </div>
          <div class="presenter_notes">
            <header><h1>Presenter Notes</h1></header>
            <section>
            
            </section>
          </div>


          <footer>
            
            <aside class="source">
              Source: <a href="lecture12.md">lecture12.md</a>
            </aside>
            
            <aside class="page_number">
              13/63
            </aside>

          </footer>
        </div>
      </div>
      
      <!-- slide source: lecture12.md -->
      <div class="slide-wrapper">
        <div class="slide">
          <div class="inner">
            
            <header><h1>Type Class Hierarchy</h1></header>
            
            
            <section><p><img src="images/lecture12/type-classes.png" height="420"></p></section>
            
          </div>
          <div class="presenter_notes">
            <header><h1>Presenter Notes</h1></header>
            <section>
            
            </section>
          </div>


          <footer>
            
            <aside class="source">
              Source: <a href="lecture12.md">lecture12.md</a>
            </aside>
            
            <aside class="page_number">
              14/63
            </aside>

          </footer>
        </div>
      </div>
      
      <!-- slide source: lecture12.md -->
      <div class="slide-wrapper">
        <div class="slide has_code">
          <div class="inner">
            
            
            <section><p>Each type class represents a particular set of sequencing semantics.
<br />
<br /></p>
<div class="highlight"><pre><span></span><span class="k">def</span> <span class="n">compose</span><span class="o">(</span><span class="n">f</span><span class="k">:</span> <span class="kt">A</span> <span class="o">=&gt;</span> <span class="n">B</span><span class="o">)</span><span class="k">:</span>       <span class="kt">A</span>  <span class="o">=&gt;</span>   <span class="n">B</span>
<span class="k">def</span>     <span class="n">map</span><span class="o">(</span><span class="n">f</span><span class="k">:</span> <span class="kt">A</span> <span class="o">=&gt;</span> <span class="n">B</span><span class="o">)</span><span class="k">:</span>     <span class="kt">F</span><span class="o">[</span><span class="kt">A</span><span class="o">]</span> <span class="k">=&gt;</span> <span class="n">F</span><span class="o">[</span><span class="kt">B</span><span class="o">]</span>
<span class="k">def</span>     <span class="n">ap</span><span class="o">(</span><span class="n">f</span><span class="k">:</span><span class="kt">F</span><span class="o">[</span><span class="kt">A</span> <span class="k">=&gt;</span> <span class="kt">B</span><span class="o">])</span><span class="k">:</span>    <span class="kt">F</span><span class="o">[</span><span class="kt">A</span><span class="o">]</span> <span class="k">=&gt;</span> <span class="n">F</span><span class="o">[</span><span class="kt">B</span><span class="o">]</span>
<span class="k">def</span> <span class="n">flatMap</span><span class="o">(</span><span class="n">f</span><span class="k">:</span> <span class="kt">A</span> <span class="o">=&gt;</span> <span class="n">F</span><span class="o">[</span><span class="kt">B</span><span class="o">])</span><span class="k">:</span>  <span class="kt">F</span><span class="o">[</span><span class="kt">A</span><span class="o">]</span> <span class="k">=&gt;</span> <span class="n">F</span><span class="o">[</span><span class="kt">B</span><span class="o">]</span>
</pre></div>
</section>
            
          </div>
          <div class="presenter_notes">
            <header><h1>Presenter Notes</h1></header>
            <section>
            
            </section>
          </div>


          <footer>
            
            <aside class="source">
              Source: <a href="lecture12.md">lecture12.md</a>
            </aside>
            
            <aside class="page_number">
              15/63
            </aside>

          </footer>
        </div>
      </div>
      
      <!-- slide source: lecture12.md -->
      <div class="slide-wrapper">
        <div class="slide">
          <div class="inner">
            
            
            <section><p>Each type class introduces its characteristic methods, and defines all of the functionality from its supertypes in terms of them (e.g. every monad is an applicative, every applicative a cartesian, etc).
<br />
<br />
Therefore inheritance relationships are constant across all instances of a particular type class.</p></section>
            
          </div>
          <div class="presenter_notes">
            <header><h1>Presenter Notes</h1></header>
            <section>
            
            </section>
          </div>


          <footer>
            
            <aside class="source">
              Source: <a href="lecture12.md">lecture12.md</a>
            </aside>
            
            <aside class="page_number">
              16/63
            </aside>

          </footer>
        </div>
      </div>
      
      <!-- slide source: lecture12.md -->
      <div class="slide-wrapper">
        <div class="slide has_code">
          <div class="inner">
            
            
            <section><p>For example, Monad defines<code>product</code>, <code>ap</code>, and <code>map</code>, in terms of <code>pure</code> and <code>flatMap</code>:</p>
<div class="highlight"><pre><span></span><span class="k">trait</span> <span class="nc">Monad</span><span class="o">[</span><span class="kt">F</span><span class="o">[</span><span class="k">_</span><span class="o">]]</span> <span class="nc">extends</span> <span class="nc">FlatMap</span><span class="o">[</span><span class="kt">F</span><span class="o">]</span> <span class="k">with</span> <span class="nc">Applicative</span><span class="o">[</span><span class="kt">F</span><span class="o">]</span> <span class="o">{</span>
  <span class="k">def</span> <span class="n">product</span><span class="o">[</span><span class="kt">A</span>, <span class="kt">B</span><span class="o">](</span><span class="n">fa</span><span class="k">:</span> <span class="kt">F</span><span class="o">[</span><span class="kt">A</span><span class="o">],</span> <span class="n">fb</span><span class="k">:</span> <span class="kt">F</span><span class="o">[</span><span class="kt">B</span><span class="o">])</span><span class="k">:</span> <span class="kt">F</span><span class="o">[(</span><span class="kt">A</span>, <span class="kt">B</span><span class="o">)]</span> <span class="k">=</span>
    <span class="n">flatMap</span><span class="o">(</span><span class="n">fa</span><span class="o">)(</span><span class="n">a</span> <span class="k">=&gt;</span> <span class="n">map</span><span class="o">(</span><span class="n">fb</span><span class="o">)(</span><span class="n">b</span> <span class="k">=&gt;</span> <span class="o">(</span><span class="n">a</span><span class="o">,</span> <span class="n">b</span><span class="o">)))</span>
  <span class="k">def</span> <span class="n">ap</span><span class="o">[</span><span class="kt">A</span>, <span class="kt">B</span><span class="o">](</span><span class="n">ff</span><span class="k">:</span> <span class="kt">F</span><span class="o">[</span><span class="kt">A</span> <span class="k">=&gt;</span> <span class="kt">B</span><span class="o">])(</span><span class="n">fa</span><span class="k">:</span> <span class="kt">F</span><span class="o">[</span><span class="kt">A</span><span class="o">])</span><span class="k">:</span> <span class="kt">F</span><span class="o">[</span><span class="kt">B</span><span class="o">]</span> <span class="k">=</span>
    <span class="n">flatMap</span><span class="o">(</span><span class="n">ff</span><span class="o">)(</span><span class="n">f</span> <span class="k">=&gt;</span> <span class="n">map</span><span class="o">(</span><span class="n">fa</span><span class="o">)(</span><span class="n">f</span><span class="o">))</span>
  <span class="k">def</span> <span class="n">map</span><span class="o">[</span><span class="kt">A</span>, <span class="kt">B</span><span class="o">](</span><span class="n">fa</span><span class="k">:</span> <span class="kt">F</span><span class="o">[</span><span class="kt">A</span><span class="o">])(</span><span class="n">f</span><span class="k">:</span> <span class="kt">A</span> <span class="o">=&gt;</span> <span class="n">B</span><span class="o">)</span><span class="k">:</span> <span class="kt">F</span><span class="o">[</span><span class="kt">B</span><span class="o">]</span> <span class="k">=</span>
    <span class="n">flatMap</span><span class="o">(</span><span class="n">a</span> <span class="k">=&gt;</span> <span class="n">pure</span><span class="o">(</span><span class="n">f</span><span class="o">(</span><span class="n">a</span><span class="o">)))</span>
<span class="o">}</span>
</pre></div>
</section>
            
          </div>
          <div class="presenter_notes">
            <header><h1>Presenter Notes</h1></header>
            <section>
            
            </section>
          </div>


          <footer>
            
            <aside class="source">
              Source: <a href="lecture12.md">lecture12.md</a>
            </aside>
            
            <aside class="page_number">
              17/63
            </aside>

          </footer>
        </div>
      </div>
      
      <!-- slide source: lecture12.md -->
      <div class="slide-wrapper">
        <div class="slide has_code">
          <div class="inner">
            
            <header><h1>Cartsian</h1></header>
            
            
            <section><div class="highlight"><pre><span></span><span class="k">import</span> <span class="nn">cats.Cartesian</span>
<span class="k">import</span> <span class="nn">cats.std.option._</span>
<span class="nc">Cartesian</span><span class="o">[</span><span class="kt">Option</span><span class="o">].</span><span class="n">product</span><span class="o">(</span><span class="nc">Some</span><span class="o">(</span><span class="mi">123</span><span class="o">),</span> <span class="nc">Some</span><span class="o">(</span><span class="s">&quot;abc&quot;</span><span class="o">))</span>
<span class="c1">//res0: Option[(Int, String)] = Some((123,abc))</span>
</pre></div>
</section>
            
          </div>
          <div class="presenter_notes">
            <header><h1>Presenter Notes</h1></header>
            <section>
            
            </section>
          </div>


          <footer>
            
            <aside class="source">
              Source: <a href="lecture12.md">lecture12.md</a>
            </aside>
            
            <aside class="page_number">
              18/63
            </aside>

          </footer>
        </div>
      </div>
      
      <!-- slide source: lecture12.md -->
      <div class="slide-wrapper">
        <div class="slide has_code">
          <div class="inner">
            
            
            <section><p>If either argument evaluates to <code>None</code>, the entire result is <code>None</code>:</p>
<div class="highlight"><pre><span></span><span class="nc">Cartesian</span><span class="o">[</span><span class="kt">Option</span><span class="o">].</span><span class="n">product</span><span class="o">(</span><span class="nc">None</span><span class="o">,</span> <span class="nc">Some</span><span class="o">(</span><span class="s">&quot;abc&quot;</span><span class="o">))</span>
<span class="c1">//res1: Option[(Nothing, String)] = None</span>
<span class="nc">Cartesian</span><span class="o">[</span><span class="kt">Option</span><span class="o">].</span><span class="n">product</span><span class="o">(</span><span class="nc">Some</span><span class="o">(</span><span class="mi">123</span><span class="o">),</span> <span class="nc">None</span><span class="o">)</span>
<span class="c1">//res2: Option[(Int, Nothing)] = None</span>
</pre></div>
</section>
            
          </div>
          <div class="presenter_notes">
            <header><h1>Presenter Notes</h1></header>
            <section>
            
            </section>
          </div>


          <footer>
            
            <aside class="source">
              Source: <a href="lecture12.md">lecture12.md</a>
            </aside>
            
            <aside class="page_number">
              19/63
            </aside>

          </footer>
        </div>
      </div>
      
      <!-- slide source: lecture12.md -->
      <div class="slide-wrapper">
        <div class="slide has_code">
          <div class="inner">
            
            
            <section><p>The <code>|@|</code> operator, better known as the 'tie fighter', provides infix syntax for this:</p>
<div class="highlight"><pre><span></span><span class="o">(</span><span class="nc">List</span><span class="o">(</span><span class="mi">1</span><span class="o">,</span><span class="mi">2</span><span class="o">,</span><span class="mi">3</span><span class="o">)</span> <span class="o">|@|</span> <span class="nc">List</span><span class="o">(</span><span class="mi">4</span><span class="o">,</span><span class="mi">5</span><span class="o">,</span><span class="mi">6</span><span class="o">)).</span><span class="n">tupled</span>
<span class="c1">//List((1,4),(1,5),(1,6),(2,4),(2,5),(2,6),(3,4),(3,5),(3,6))</span>
<span class="o">(</span><span class="nc">Xor</span><span class="o">.</span><span class="n">right</span><span class="o">(</span><span class="mi">123</span><span class="o">)</span> <span class="o">|@|</span> <span class="nc">Xor</span><span class="o">.</span><span class="n">right</span><span class="o">(</span><span class="s">&quot;abc&quot;</span><span class="o">)).</span><span class="n">tupled</span>
<span class="c1">//res3: Xor[Nothing,(Int, String)] = Right((123,abc))</span>
</pre></div>
</section>
            
          </div>
          <div class="presenter_notes">
            <header><h1>Presenter Notes</h1></header>
            <section>
            
            </section>
          </div>


          <footer>
            
            <aside class="source">
              Source: <a href="lecture12.md">lecture12.md</a>
            </aside>
            
            <aside class="page_number">
              20/63
            </aside>

          </footer>
        </div>
      </div>
      
      <!-- slide source: lecture12.md -->
      <div class="slide-wrapper">
        <div class="slide has_code">
          <div class="inner">
            
            
            <section><p><code>|@|</code> creates an intermediate <code>builder</code> object that provides several methods for combining the parameters to create useful data types.</p>
<p>The idiomatic way of using builder syntax is to combine <code>|@|</code> and <code>tupled</code> in a single expression, going from single values to a tuple in one step:</p>
<div class="highlight"><pre><span></span><span class="o">(</span>
  <span class="nc">Option</span><span class="o">(</span><span class="mi">1</span><span class="o">)</span> <span class="o">|@|</span>
  <span class="nc">Option</span><span class="o">(</span><span class="mi">2</span><span class="o">)</span> <span class="o">|@|</span>
  <span class="nc">Option</span><span class="o">(</span><span class="mi">3</span><span class="o">)</span>
<span class="o">).</span><span class="n">tupled</span>
<span class="c1">//res4: Option[(Int, Int, Int)] = Some((1,2,3))</span>
</pre></div>
</section>
            
          </div>
          <div class="presenter_notes">
            <header><h1>Presenter Notes</h1></header>
            <section>
            
            </section>
          </div>


          <footer>
            
            <aside class="source">
              Source: <a href="lecture12.md">lecture12.md</a>
            </aside>
            
            <aside class="page_number">
              21/63
            </aside>

          </footer>
        </div>
      </div>
      
      <!-- slide source: lecture12.md -->
      <div class="slide-wrapper">
        <div class="slide has_code">
          <div class="inner">
            
            
            <section><p><code>|@|</code> is associative:</p>
<div class="highlight"><pre><span></span><span class="k">val</span> <span class="n">three</span> <span class="k">=</span> <span class="nc">Option</span><span class="o">(</span><span class="mi">123</span><span class="o">)</span> <span class="o">|@|</span> <span class="nc">Option</span><span class="o">(</span><span class="s">&quot;abc&quot;</span><span class="o">)</span> <span class="o">|@|</span> <span class="nc">Option</span><span class="o">(</span><span class="kc">true</span><span class="o">)</span>
<span class="n">three</span><span class="o">.</span><span class="n">tupled</span>
<span class="c1">//Some((123,abc,true))</span>
<span class="k">val</span> <span class="n">five</span> <span class="k">=</span> <span class="n">three</span> <span class="o">|@|</span> <span class="nc">Option</span><span class="o">(</span><span class="mf">0.5</span><span class="o">)</span> <span class="o">|@|</span> <span class="nc">Option</span><span class="o">(</span><span class="sc">&#39;x&#39;</span><span class="o">)</span>
<span class="n">five</span><span class="o">.</span><span class="n">tupled</span>
<span class="c1">//Some((123,abc,true,0.5,x))</span>
</pre></div>
</section>
            
          </div>
          <div class="presenter_notes">
            <header><h1>Presenter Notes</h1></header>
            <section>
            
            </section>
          </div>


          <footer>
            
            <aside class="source">
              Source: <a href="lecture12.md">lecture12.md</a>
            </aside>
            
            <aside class="page_number">
              22/63
            </aside>

          </footer>
        </div>
      </div>
      
      <!-- slide source: lecture12.md -->
      <div class="slide-wrapper">
        <div class="slide has_code">
          <div class="inner">
            
            
            <section><p>Every builder also has a <code>map</code> method that accepts a function of the correct arity and implicit instances of <code>Cartesian</code> and <code>Functor</code>:</p>
<div class="highlight"><pre><span></span><span class="o">(</span>
  <span class="nc">Option</span><span class="o">(</span><span class="mi">1</span><span class="o">)</span> <span class="o">|@|</span>
  <span class="nc">Option</span><span class="o">(</span><span class="mi">2</span><span class="o">)</span>
<span class="o">).</span><span class="n">map</span><span class="o">(</span><span class="k">_</span> <span class="o">+</span> <span class="k">_</span><span class="o">)</span>
<span class="c1">//res5: Option[Int] = Some(3)</span>
</pre></div>
</section>
            
          </div>
          <div class="presenter_notes">
            <header><h1>Presenter Notes</h1></header>
            <section>
            
            </section>
          </div>


          <footer>
            
            <aside class="source">
              Source: <a href="lecture12.md">lecture12.md</a>
            </aside>
            
            <aside class="page_number">
              23/63
            </aside>

          </footer>
        </div>
      </div>
      
      <!-- slide source: lecture12.md -->
      <div class="slide-wrapper">
        <div class="slide has_code">
          <div class="inner">
            
            
            <section><p>Or apply parameters to create a case class:</p>
<div class="highlight"><pre><span></span><span class="k">case</span> <span class="k">class</span> <span class="nc">Address</span><span class="o">(</span><span class="n">name</span><span class="k">:</span> <span class="kt">String</span><span class="o">,</span> <span class="n">number</span><span class="k">:</span> <span class="kt">Int</span><span class="o">,</span> <span class="n">street</span><span class="k">:</span> <span class="kt">String</span><span class="o">)</span>
<span class="o">(</span>
  <span class="nc">Option</span><span class="o">(</span><span class="s">&quot;DataScience&quot;</span><span class="o">)</span> <span class="o">|@|</span>
  <span class="nc">Option</span><span class="o">(</span><span class="mi">200</span><span class="o">)</span>       <span class="o">|@|</span>
  <span class="nc">Option</span><span class="o">(</span><span class="s">&quot;Corporate Pointe&quot;</span><span class="o">)</span>
<span class="o">).</span><span class="n">map</span><span class="o">(</span><span class="nc">Cat</span><span class="o">.</span><span class="n">apply</span><span class="o">)</span>
<span class="c1">//res6 = Some(Address(DataScience,200,Corporate Pointe))</span>
</pre></div>
</section>
            
          </div>
          <div class="presenter_notes">
            <header><h1>Presenter Notes</h1></header>
            <section>
            
            </section>
          </div>


          <footer>
            
            <aside class="source">
              Source: <a href="lecture12.md">lecture12.md</a>
            </aside>
            
            <aside class="page_number">
              24/63
            </aside>

          </footer>
        </div>
      </div>
      
      <!-- slide source: lecture12.md -->
      <div class="slide-wrapper">
        <div class="slide">
          <div class="inner">
            
            <header><h1>Applicative laws</h1></header>
            
            
            <section><p>The book presents the applicative laws in terms of <code>map2</code>:</p>
<ul>
<li>Left identity: <code>map2(unit(()), fa)((_,a) =&gt; a) == fa</code></li>
<li>Right identity: <code>map2(fa, unit(()))((a,_) =&gt; a) == fa</code></li>
<li>Associativity: <code>product(product(fa, fb),fc) == map(product(fa, product(fb, fc)))(assoc)</code></li>
<li>Naturality: <code>map2(a,b)(productF(f,g)) == product(map(a)(f), map(b)(g))</code></li>
</ul></section>
            
          </div>
          <div class="presenter_notes">
            <header><h1>Presenter Notes</h1></header>
            <section>
            
            </section>
          </div>


          <footer>
            
            <aside class="source">
              Source: <a href="lecture12.md">lecture12.md</a>
            </aside>
            
            <aside class="page_number">
              25/63
            </aside>

          </footer>
        </div>
      </div>
      
      <!-- slide source: lecture12.md -->
      <div class="slide-wrapper">
        <div class="slide">
          <div class="inner">
            
            
            <section><p>The applicative laws are more commonly stated in terms of <code>ap</code>.
<br />
<br />
The laws for <code>ap</code> are <em>identity</em>, <em>composition</em>, <em>homomorphism</em>, and <em>interchange</em>.
<br />
<br />
We'll go through them one at a time.</p></section>
            
          </div>
          <div class="presenter_notes">
            <header><h1>Presenter Notes</h1></header>
            <section>
            
            </section>
          </div>


          <footer>
            
            <aside class="source">
              Source: <a href="lecture12.md">lecture12.md</a>
            </aside>
            
            <aside class="page_number">
              26/63
            </aside>

          </footer>
        </div>
      </div>
      
      <!-- slide source: lecture12.md -->
      <div class="slide-wrapper">
        <div class="slide has_code has_notes">
          <div class="inner">
            
            <header><h1>Identity</h1></header>
            
            
            <section><p>The identity law for <code>apply</code> is stated as:</p>
<div class="highlight"><pre><span></span><span class="n">ap</span><span class="o">(</span><span class="n">pure</span><span class="o">(</span><span class="n">id</span><span class="o">))(</span><span class="n">v</span><span class="o">)</span> <span class="o">==</span> <span class="n">v</span>
</pre></div>

<p>The identity law says that embedding the identity function in the monoid and applying it to a value results in no change.</p>
<p class="notes">pure id &lt;*&gt; v = v</p></section>
            
          </div>
          <div class="presenter_notes">
            <header><h1>Presenter Notes</h1></header>
            <section>
            
            </section>
          </div>


          <footer>
            
            <aside class="source">
              Source: <a href="lecture12.md">lecture12.md</a>
            </aside>
            
            <aside class="page_number">
              27/63
            </aside>

          </footer>
        </div>
      </div>
      
      <!-- slide source: lecture12.md -->
      <div class="slide-wrapper">
        <div class="slide has_code has_notes">
          <div class="inner">
            
            <header><h1>Composition</h1></header>
            
            
            <section><p>The composition law for <code>ap</code> is stated as:</p>
<div class="highlight"><pre><span></span><span class="n">ap</span><span class="o">(</span><span class="n">u</span><span class="o">)(</span><span class="n">ap</span><span class="o">(</span><span class="n">v</span><span class="o">)(</span><span class="n">w</span><span class="o">))</span> <span class="o">==</span>
<span class="n">ap</span><span class="o">(</span><span class="n">ap</span><span class="o">(</span><span class="n">ap</span><span class="o">(</span><span class="n">pure</span><span class="o">(</span><span class="n">f</span> <span class="k">=&gt;</span> <span class="n">g</span> <span class="k">=&gt;</span> <span class="n">f</span> <span class="n">compose</span> <span class="n">g</span><span class="o">))(</span><span class="n">u</span><span class="o">))(</span><span class="n">v</span><span class="o">))(</span><span class="n">w</span><span class="o">)</span>
</pre></div>

<p class="notes">pure(.) &lt;<em>&gt; u &lt;</em>&gt; v &lt;<em>&gt; w = u &lt;</em>&gt; (v &lt;*&gt; w)</p></section>
            
          </div>
          <div class="presenter_notes">
            <header><h1>Presenter Notes</h1></header>
            <section>
            
            </section>
          </div>


          <footer>
            
            <aside class="source">
              Source: <a href="lecture12.md">lecture12.md</a>
            </aside>
            
            <aside class="page_number">
              28/63
            </aside>

          </footer>
        </div>
      </div>
      
      <!-- slide source: lecture12.md -->
      <div class="slide-wrapper">
        <div class="slide">
          <div class="inner">
            
            
            <section><p>The composition law says applying <code>v</code> to <code>w</code> and then applying <code>u</code> to that is the same as applying composition to <code>u</code>, then <code>v</code>, and then applying the composite function to <code>w</code>.
<br />
<br />
We might state this law simply as: "function composition in an applicative functor works in the obvious way."
<br />
<br />
This is analagous to the composition law for <code>Functor</code>.</p></section>
            
          </div>
          <div class="presenter_notes">
            <header><h1>Presenter Notes</h1></header>
            <section>
            
            </section>
          </div>


          <footer>
            
            <aside class="source">
              Source: <a href="lecture12.md">lecture12.md</a>
            </aside>
            
            <aside class="page_number">
              29/63
            </aside>

          </footer>
        </div>
      </div>
      
      <!-- slide source: lecture12.md -->
      <div class="slide-wrapper">
        <div class="slide has_code has_notes">
          <div class="inner">
            
            <header><h1>Homomorphism</h1></header>
            
            
            <section><p>The homomorphism law for <code>ap</code> is stated as:</p>
<div class="highlight"><pre><span></span><span class="n">ap</span><span class="o">(</span><span class="n">pure</span><span class="o">(</span><span class="n">f</span><span class="o">))(</span><span class="n">pure</span><span class="o">(</span><span class="n">x</span><span class="o">))</span> <span class="o">==</span> <span class="n">pure</span><span class="o">(</span><span class="n">f</span><span class="o">(</span><span class="n">x</span><span class="o">))</span>
</pre></div>

<p class="notes">pure f &lt;*&gt; pure x = pure (f x)</p></section>
            
          </div>
          <div class="presenter_notes">
            <header><h1>Presenter Notes</h1></header>
            <section>
            
            </section>
          </div>


          <footer>
            
            <aside class="source">
              Source: <a href="lecture12.md">lecture12.md</a>
            </aside>
            
            <aside class="page_number">
              30/63
            </aside>

          </footer>
        </div>
      </div>
      
      <!-- slide source: lecture12.md -->
      <div class="slide-wrapper">
        <div class="slide">
          <div class="inner">
            
            
            <section><p>The homomorphism law says that idiomatic function application on <code>pure</code>s is the same as the <code>pure</code> of regular function application.
<br />
<br />
More precisely, <code>pure</code> is a homomorphism from <code>A</code> to <code>F[A]</code> with regard to function application.</p></section>
            
          </div>
          <div class="presenter_notes">
            <header><h1>Presenter Notes</h1></header>
            <section>
            
            </section>
          </div>


          <footer>
            
            <aside class="source">
              Source: <a href="lecture12.md">lecture12.md</a>
            </aside>
            
            <aside class="page_number">
              31/63
            </aside>

          </footer>
        </div>
      </div>
      
      <!-- slide source: lecture12.md -->
      <div class="slide-wrapper">
        <div class="slide has_code has_notes">
          <div class="inner">
            
            <header><h1>Interchange</h1></header>
            
            
            <section><p>The interchange law for <code>ap</code> is stated as:</p>
<div class="highlight"><pre><span></span><span class="n">ap</span><span class="o">(</span><span class="n">u</span><span class="o">)(</span><span class="n">pure</span><span class="o">(</span><span class="n">y</span><span class="o">))</span> <span class="o">==</span> <span class="n">ap</span><span class="o">(</span><span class="n">pure</span><span class="o">(</span><span class="k">_</span><span class="o">(</span><span class="n">y</span><span class="o">)))(</span><span class="n">u</span><span class="o">)</span>
</pre></div>

<p class="notes">u &lt;<em>&gt; pure y = pure ($ y) &lt;</em>&gt; u</p></section>
            
          </div>
          <div class="presenter_notes">
            <header><h1>Presenter Notes</h1></header>
            <section>
            
            </section>
          </div>


          <footer>
            
            <aside class="source">
              Source: <a href="lecture12.md">lecture12.md</a>
            </aside>
            
            <aside class="page_number">
              32/63
            </aside>

          </footer>
        </div>
      </div>
      
      <!-- slide source: lecture12.md -->
      <div class="slide-wrapper">
        <div class="slide">
          <div class="inner">
            
            
            <section><p>The interchange law is essentially saying that <code>pure</code> is not allowed to carry an effect with regard to any implementation of our applicative functor.
<br />
<br />
If one argument to <code>ap</code> is a <code>pure</code>, then the other can appear in either position.</p></section>
            
          </div>
          <div class="presenter_notes">
            <header><h1>Presenter Notes</h1></header>
            <section>
            
            </section>
          </div>


          <footer>
            
            <aside class="source">
              Source: <a href="lecture12.md">lecture12.md</a>
            </aside>
            
            <aside class="page_number">
              33/63
            </aside>

          </footer>
        </div>
      </div>
      
      <!-- slide source: lecture12.md -->
      <div class="slide-wrapper">
        <div class="slide has_code">
          <div class="inner">
            
            
            <section><p>The applicative laws taken together can be seen as saying that we can rewrite any expression involving <code>pure</code> or <code>ap</code> (and therefore by extension <code>map2</code>), into a normal form having one of the following shapes:</p>
<div class="highlight"><pre><span></span><span class="n">pure</span><span class="o">(</span><span class="n">x</span><span class="o">)</span>          <span class="c1">// for some x</span>
<span class="n">map</span><span class="o">(</span><span class="n">x</span><span class="o">)(</span><span class="n">f</span><span class="o">)</span>        <span class="c1">// for some x and f</span>
<span class="n">map2</span><span class="o">(</span><span class="n">x</span><span class="o">,</span> <span class="n">y</span><span class="o">)(</span><span class="n">f</span><span class="o">)</span>    <span class="c1">// for some x, y, and f</span>
<span class="n">map3</span><span class="o">(</span><span class="n">x</span><span class="o">,</span> <span class="n">y</span><span class="o">,</span> <span class="n">z</span><span class="o">)(</span><span class="n">f</span><span class="o">)</span> <span class="c1">// for some x, y, z, and f</span>
<span class="c1">//...etc</span>
</pre></div>

<p>That is, every expression in an applicative functor <code>A</code> can be seen as lifting some pure function <code>f</code> over a number of arguments in <code>A</code>.</p></section>
            
          </div>
          <div class="presenter_notes">
            <header><h1>Presenter Notes</h1></header>
            <section>
            
            </section>
          </div>


          <footer>
            
            <aside class="source">
              Source: <a href="lecture12.md">lecture12.md</a>
            </aside>
            
            <aside class="page_number">
              34/63
            </aside>

          </footer>
        </div>
      </div>
      
      <!-- slide source: lecture12.md -->
      <div class="slide-wrapper">
        <div class="slide">
          <div class="inner">
            
            
            <section><p>The applicative laws amount to saying that the arguments to <code>map</code>, <code>map2</code>, <code>map3</code>, etc can be reasoned about independently, and an expression like <code>flatMap(x)(f)</code> explicitly introduces a dependency (so that the result of <code>f</code> depends on <code>x</code>).
<br />
<br />
Note that this reasoning is lost when the applicative happens to be a monad and the expressions involve <code>flatMap</code>.</p></section>
            
          </div>
          <div class="presenter_notes">
            <header><h1>Presenter Notes</h1></header>
            <section>
            
            </section>
          </div>


          <footer>
            
            <aside class="source">
              Source: <a href="lecture12.md">lecture12.md</a>
            </aside>
            
            <aside class="page_number">
              35/63
            </aside>

          </footer>
        </div>
      </div>
      
      <!-- slide source: lecture12.md -->
      <div class="slide-wrapper">
        <div class="slide">
          <div class="inner">
            
            <header><h1>Monads vs Applicatives</h1></header>
            
            
            <section><p>There is a tradeoff between applicative APIs and monadic ones.
<br />
<br />
Monadic APIs are strictly more powerful and flexible, but the cost is a certain loss of algebraic reasoning.
<br />
<br />
The difference is easy to demonstrate in theory, but takes some experience to fully appreciate in practice.</p></section>
            
          </div>
          <div class="presenter_notes">
            <header><h1>Presenter Notes</h1></header>
            <section>
            
            </section>
          </div>


          <footer>
            
            <aside class="source">
              Source: <a href="lecture12.md">lecture12.md</a>
            </aside>
            
            <aside class="page_number">
              36/63
            </aside>

          </footer>
        </div>
      </div>
      
      <!-- slide source: lecture12.md -->
      <div class="slide-wrapper">
        <div class="slide has_code">
          <div class="inner">
            
            
            <section><p>Consider composition in a monad, combining values with <code>compose</code> (Kleisli composition):</p>
<div class="highlight"><pre><span></span><span class="k">val</span> <span class="n">fooM</span><span class="k">:</span> <span class="kt">A</span> <span class="o">=&gt;</span> <span class="n">F</span><span class="o">[</span><span class="kt">B</span><span class="o">]</span> <span class="k">=</span> <span class="o">???</span>
<span class="k">val</span> <span class="n">barM</span><span class="k">:</span> <span class="kt">B</span> <span class="o">=&gt;</span> <span class="n">F</span><span class="o">[</span><span class="kt">C</span><span class="o">]</span> <span class="k">=</span> <span class="o">???</span>
<span class="k">val</span> <span class="n">bazM</span><span class="k">:</span> <span class="kt">A</span> <span class="o">=&gt;</span> <span class="n">F</span><span class="o">[</span><span class="kt">C</span><span class="o">]</span> <span class="k">=</span> <span class="n">barM</span> <span class="n">compose</span> <span class="n">fooM</span>
</pre></div>
</section>
            
          </div>
          <div class="presenter_notes">
            <header><h1>Presenter Notes</h1></header>
            <section>
            
            </section>
          </div>


          <footer>
            
            <aside class="source">
              Source: <a href="lecture12.md">lecture12.md</a>
            </aside>
            
            <aside class="page_number">
              37/63
            </aside>

          </footer>
        </div>
      </div>
      
      <!-- slide source: lecture12.md -->
      <div class="slide-wrapper">
        <div class="slide">
          <div class="inner">
            
            
            <section><p>There is no way that the implementation of the <code>compose</code> function in the <code>Monad[F]</code> instance can inspect the values <code>foo</code> and <code>bar</code>.
<br />
<br />
They are functions, so the only way to 'see inside' them is to give them arguments.
<br />
<br />
The values of type <code>F[B]</code> and <code>F[C]</code> respectively are not determined until the composite function <em>runs</em>.</p></section>
            
          </div>
          <div class="presenter_notes">
            <header><h1>Presenter Notes</h1></header>
            <section>
            
            </section>
          </div>


          <footer>
            
            <aside class="source">
              Source: <a href="lecture12.md">lecture12.md</a>
            </aside>
            
            <aside class="page_number">
              38/63
            </aside>

          </footer>
        </div>
      </div>
      
      <!-- slide source: lecture12.md -->
      <div class="slide-wrapper">
        <div class="slide has_code">
          <div class="inner">
            
            
            <section><p>Now consider composition in an applicative, combining values with <code>map2</code>:</p>
<div class="highlight"><pre><span></span><span class="k">val</span> <span class="n">fooA</span><span class="k">:</span> <span class="kt">F</span><span class="o">[</span><span class="kt">A</span><span class="o">]</span> <span class="k">=</span> <span class="o">???</span>
<span class="k">val</span> <span class="n">barA</span><span class="k">:</span> <span class="kt">F</span><span class="o">[</span><span class="kt">B</span><span class="o">]</span> <span class="k">=</span> <span class="o">???</span>
<span class="k">val</span> <span class="n">bazA</span><span class="k">:</span> <span class="kt">F</span><span class="o">[</span><span class="kt">C</span><span class="o">]</span> <span class="k">=</span> <span class="n">map2</span><span class="o">(</span><span class="n">fooA</span><span class="o">,</span> <span class="n">barA</span><span class="o">)(</span><span class="n">f</span><span class="o">)</span>
</pre></div>
</section>
            
          </div>
          <div class="presenter_notes">
            <header><h1>Presenter Notes</h1></header>
            <section>
            
            </section>
          </div>


          <footer>
            
            <aside class="source">
              Source: <a href="lecture12.md">lecture12.md</a>
            </aside>
            
            <aside class="page_number">
              39/63
            </aside>

          </footer>
        </div>
      </div>
      
      <!-- slide source: lecture12.md -->
      <div class="slide-wrapper">
        <div class="slide">
          <div class="inner">
            
            
            <section><p>Here the implementation of <code>map2</code> can actually look at the values <code>fooA</code> and <code>barA</code>, and take different actions depending on what they are.
<br />
<br />
If <code>F</code> is something like <code>Future</code>, it might decide to start immediately evaluating them on different threads.
<br />
<br />
If the data type <code>F</code> is applicative but <em>not a monad</em>, then the implementation has this flexibility universally because an expression in <code>F</code> will never involve functions of the form <code>A =&gt; F[B]</code> that it can't see inside of.</p></section>
            
          </div>
          <div class="presenter_notes">
            <header><h1>Presenter Notes</h1></header>
            <section>
            
            </section>
          </div>


          <footer>
            
            <aside class="source">
              Source: <a href="lecture12.md">lecture12.md</a>
            </aside>
            
            <aside class="page_number">
              40/63
            </aside>

          </footer>
        </div>
      </div>
      
      <!-- slide source: lecture12.md -->
      <div class="slide-wrapper">
        <div class="slide">
          <div class="inner">
            
            
            <section><p>Because <code>Applicative</code> is 'weaker' than <code>Monad</code>, this gives the interpreter of applicative effects more flexibility.
<br />
<br />
<code>Applicative</code> is therefore generally preferred to <code>Monad</code> when the structure of a computation is fixed a priori.
<br />
<br />
That makes it possible to perform certain kinds of static analysis on applicative values.</p></section>
            
          </div>
          <div class="presenter_notes">
            <header><h1>Presenter Notes</h1></header>
            <section>
            
            </section>
          </div>


          <footer>
            
            <aside class="source">
              Source: <a href="lecture12.md">lecture12.md</a>
            </aside>
            
            <aside class="page_number">
              41/63
            </aside>

          </footer>
        </div>
      </div>
      
      <!-- slide source: lecture12.md -->
      <div class="slide-wrapper">
        <div class="slide">
          <div class="inner">
            
            
            <section><p>For example, if we describe a parser without resorting to <code>flatMap</code>, this implies that the structure of our grammar is determined before we begin parsing.
<br />
<br />
Therefore, our interpreter or runner of parsers has more information about what it’ll be doing up front and is free to make additional assumptions and use a more efficient implementation strategy.
<br />
<br />
Adding <code>flatMap</code> is powerful, but it means we’re generating our parsers dynamically, so the interpreter may be more limited in what it can do.</p></section>
            
          </div>
          <div class="presenter_notes">
            <header><h1>Presenter Notes</h1></header>
            <section>
            
            </section>
          </div>


          <footer>
            
            <aside class="source">
              Source: <a href="lecture12.md">lecture12.md</a>
            </aside>
            
            <aside class="page_number">
              42/63
            </aside>

          </footer>
        </div>
      </div>
      
      <!-- slide source: lecture12.md -->
      <div class="slide-wrapper">
        <div class="slide">
          <div class="inner">
            
            
            <section><p>The lesson here is that power and flexibility in the interface often restricts power and flexibility in the implementation.
<br />
<br />
And a more restricted interface often gives the implementation more options.
<br />
<br />
See <a href="http://stackoverflow.com/questions/7861903/what-are-the-benefits-of-applicative-parsing-over-monadic-parsing">this StackOverflow question</a> for further discussion of the issue with regard to parsers.</p></section>
            
          </div>
          <div class="presenter_notes">
            <header><h1>Presenter Notes</h1></header>
            <section>
            
            </section>
          </div>


          <footer>
            
            <aside class="source">
              Source: <a href="lecture12.md">lecture12.md</a>
            </aside>
            
            <aside class="page_number">
              43/63
            </aside>

          </footer>
        </div>
      </div>
      
      <!-- slide source: lecture12.md -->
      <div class="slide-wrapper">
        <div class="slide">
          <div class="inner">
            
            
            <section><p>A more algebraic manifestation of the difference is that, like <code>Functor</code> and <code>Apply</code>, applicative functors also compose naturally with each other.
<br />
<br />
When you compose one <code>Applicative</code> with another, the resulting <code>pure</code> operation will lift the passed value into one context, and the result into the other context.
<br />
<br />
We've seen however that monads do not in general compose with each other without some 'hand wiring'.</p></section>
            
          </div>
          <div class="presenter_notes">
            <header><h1>Presenter Notes</h1></header>
            <section>
            
            </section>
          </div>


          <footer>
            
            <aside class="source">
              Source: <a href="lecture12.md">lecture12.md</a>
            </aside>
            
            <aside class="page_number">
              44/63
            </aside>

          </footer>
        </div>
      </div>
      
      <!-- slide source: lecture12.md -->
      <div class="slide-wrapper">
        <div class="slide has_code">
          <div class="inner">
            
            
            <section><div class="highlight"><pre><span></span><span class="k">val</span> <span class="n">listOpt</span> <span class="k">=</span> <span class="nc">Apply</span><span class="o">[</span><span class="kt">List</span><span class="o">]</span> <span class="n">compose</span> <span class="nc">Apply</span><span class="o">[</span><span class="kt">Option</span><span class="o">]</span>
<span class="k">val</span> <span class="n">inc</span> <span class="k">=</span> <span class="o">(</span><span class="n">x</span><span class="k">:</span><span class="kt">Int</span><span class="o">)</span> <span class="k">=&gt;</span> <span class="n">x</span> <span class="o">+</span> <span class="mi">1</span>
<span class="n">listOpt</span><span class="o">.</span><span class="n">ap</span><span class="o">(</span><span class="nc">List</span><span class="o">(</span><span class="nc">Some</span><span class="o">(</span><span class="n">double</span><span class="o">),</span><span class="nc">Some</span><span class="o">(</span><span class="n">inc</span><span class="o">)))(</span><span class="nc">List</span><span class="o">(</span><span class="nc">Some</span><span class="o">(</span><span class="mi">2</span><span class="o">),</span> <span class="nc">None</span><span class="o">,</span> <span class="nc">Some</span><span class="o">(</span><span class="mi">3</span><span class="o">)))</span>
<span class="c1">//res0 = ???</span>
</pre></div>
</section>
            
          </div>
          <div class="presenter_notes">
            <header><h1>Presenter Notes</h1></header>
            <section>
            
            </section>
          </div>


          <footer>
            
            <aside class="source">
              Source: <a href="lecture12.md">lecture12.md</a>
            </aside>
            
            <aside class="page_number">
              45/63
            </aside>

          </footer>
        </div>
      </div>
      
      <!-- slide source: lecture12.md -->
      <div class="slide-wrapper">
        <div class="slide">
          <div class="inner">
            
            <header><h1>Example: Futures</h1></header>
            
            
            <section><p>A concrete example of the difference between monads and applicatives is the concurrent evaluation of <code>Future</code>s.
<br />
<br />
If we have several long-running independent tasks, it makes sense to execute them concurrently.
<br />
<br />
However, monadic comprehension only allows us to run them in sequence.</p></section>
            
          </div>
          <div class="presenter_notes">
            <header><h1>Presenter Notes</h1></header>
            <section>
            
            </section>
          </div>


          <footer>
            
            <aside class="source">
              Source: <a href="lecture12.md">lecture12.md</a>
            </aside>
            
            <aside class="page_number">
              46/63
            </aside>

          </footer>
        </div>
      </div>
      
      <!-- slide source: lecture12.md -->
      <div class="slide-wrapper">
        <div class="slide has_code">
          <div class="inner">
            
            
            <section><div class="highlight"><pre><span></span><span class="k">import</span> <span class="nn">scala.concurrent._</span>
<span class="k">import</span> <span class="nn">scala.concurrent.duration._</span>
<span class="k">import</span> <span class="nn">scala.concurrent.ExecutionContext.Implicits.global</span>
<span class="k">lazy</span> <span class="k">val</span> <span class="n">time0</span> <span class="k">=</span> <span class="nc">System</span><span class="o">.</span><span class="n">currentTimeMillis</span>
<span class="k">def</span> <span class="n">getTime</span><span class="k">:</span> <span class="kt">Long</span> <span class="o">=</span> <span class="o">{</span>
  <span class="k">val</span> <span class="n">time1</span> <span class="k">=</span> <span class="nc">System</span><span class="o">.</span><span class="n">currentTimeMillis</span> <span class="o">-</span> <span class="n">time0</span>
  <span class="nc">Thread</span><span class="o">.</span><span class="n">sleep</span><span class="o">(</span><span class="mi">1000</span><span class="o">)</span>
  <span class="n">time1</span>
  <span class="o">}</span>
</pre></div>
</section>
            
          </div>
          <div class="presenter_notes">
            <header><h1>Presenter Notes</h1></header>
            <section>
            
            </section>
          </div>


          <footer>
            
            <aside class="source">
              Source: <a href="lecture12.md">lecture12.md</a>
            </aside>
            
            <aside class="page_number">
              47/63
            </aside>

          </footer>
        </div>
      </div>
      
      <!-- slide source: lecture12.md -->
      <div class="slide-wrapper">
        <div class="slide has_code">
          <div class="inner">
            
            
            <section><p>Here three futures are started independently of one another and can execute in parallel:</p>
<div class="highlight"><pre><span></span><span class="k">val</span> <span class="n">applicativeTimes</span> <span class="k">=</span> <span class="o">(</span>
  <span class="nc">Future</span><span class="o">(</span><span class="n">getTime</span><span class="o">)</span> <span class="o">|@|</span>
  <span class="nc">Future</span><span class="o">(</span><span class="n">getTime</span><span class="o">)</span> <span class="o">|@|</span>
  <span class="nc">Future</span><span class="o">(</span><span class="n">getTime</span><span class="o">)</span>
  <span class="o">).</span><span class="n">tupled</span>
<span class="nc">Await</span><span class="o">.</span><span class="n">result</span><span class="o">(</span><span class="n">applicativeTimes</span><span class="o">,</span> <span class="nc">Duration</span><span class="o">.</span><span class="nc">Inf</span><span class="o">)</span>
<span class="c1">//res0: (Long, Long, Long) = (1942,1944,1946)</span>
</pre></div>
</section>
            
          </div>
          <div class="presenter_notes">
            <header><h1>Presenter Notes</h1></header>
            <section>
            
            </section>
          </div>


          <footer>
            
            <aside class="source">
              Source: <a href="lecture12.md">lecture12.md</a>
            </aside>
            
            <aside class="page_number">
              48/63
            </aside>

          </footer>
        </div>
      </div>
      
      <!-- slide source: lecture12.md -->
      <div class="slide-wrapper">
        <div class="slide has_code">
          <div class="inner">
            
            
            <section><p>This is in contrast to the following monadic combination, which executes them in sequence:</p>
<div class="highlight"><pre><span></span><span class="k">val</span> <span class="n">monadTimes</span> <span class="k">=</span> <span class="k">for</span> <span class="o">{</span>
  <span class="n">a</span> <span class="k">&lt;-</span> <span class="nc">Future</span><span class="o">(</span><span class="n">getTime</span><span class="o">)</span>
  <span class="n">b</span> <span class="k">&lt;-</span> <span class="nc">Future</span><span class="o">(</span><span class="n">getTime</span><span class="o">)</span>
  <span class="n">c</span> <span class="k">&lt;-</span> <span class="nc">Future</span><span class="o">(</span><span class="n">getTime</span><span class="o">)</span>
<span class="o">}</span> <span class="k">yield</span> <span class="o">(</span><span class="n">a</span><span class="o">,</span> <span class="n">b</span><span class="o">,</span> <span class="n">c</span><span class="o">)</span>
<span class="nc">Await</span><span class="o">.</span><span class="n">result</span><span class="o">(</span><span class="n">monadTimes</span><span class="o">,</span> <span class="nc">Duration</span><span class="o">.</span><span class="nc">Inf</span><span class="o">)</span>
<span class="c1">//res1: (Long, Long, Long) = (0,1003,2009)</span>
</pre></div>
</section>
            
          </div>
          <div class="presenter_notes">
            <header><h1>Presenter Notes</h1></header>
            <section>
            
            </section>
          </div>


          <footer>
            
            <aside class="source">
              Source: <a href="lecture12.md">lecture12.md</a>
            </aside>
            
            <aside class="page_number">
              49/63
            </aside>

          </footer>
        </div>
      </div>
      
      <!-- slide source: lecture12.md -->
      <div class="slide-wrapper">
        <div class="slide has_code">
          <div class="inner">
            
            <header><h1>Example: Validated</h1></header>
            
            
            <section><p>If we try to combine two failed <code>Xors</code>, only the left-most errors are retained:</p>
<div class="highlight"><pre><span></span><span class="o">(</span><span class="nc">Xor</span><span class="o">.</span><span class="n">left</span><span class="o">(</span><span class="nc">List</span><span class="o">(</span><span class="s">&quot;Fail 1&quot;</span><span class="o">))</span> <span class="o">|@|</span> <span class="nc">List</span><span class="o">(</span><span class="s">&quot;Fail 2&quot;</span><span class="o">)).</span><span class="n">tupled</span>
<span class="c1">// res2: ErrorOr[(Nothing, Nothing)] = Left(List(Fail 1))</span>
</pre></div>
</section>
            
          </div>
          <div class="presenter_notes">
            <header><h1>Presenter Notes</h1></header>
            <section>
            
            </section>
          </div>


          <footer>
            
            <aside class="source">
              Source: <a href="lecture12.md">lecture12.md</a>
            </aside>
            
            <aside class="page_number">
              50/63
            </aside>

          </footer>
        </div>
      </div>
      
      <!-- slide source: lecture12.md -->
      <div class="slide-wrapper">
        <div class="slide">
          <div class="inner">
            
            
            <section><p>If you think back to our examples regarding <code>Future</code>s, you’ll see why this is the case. <code>Xor</code> is a monad, so Cats implements product in terms of <code>flatMap</code>.
<br />
<br />
As we have seen, <code>flatMap</code> implements fail-fast error handling.</p></section>
            
          </div>
          <div class="presenter_notes">
            <header><h1>Presenter Notes</h1></header>
            <section>
            
            </section>
          </div>


          <footer>
            
            <aside class="source">
              Source: <a href="lecture12.md">lecture12.md</a>
            </aside>
            
            <aside class="page_number">
              51/63
            </aside>

          </footer>
        </div>
      </div>
      
      <!-- slide source: lecture12.md -->
      <div class="slide-wrapper">
        <div class="slide">
          <div class="inner">
            
            
            <section><p>However fail-fast semantics aren’t always the best choice.
<br />
<br />
When validating a web form, for example, we want to accumulate errors for all invalid fields, not just the first one we find.
<br />
<br />
If we model this with a monad like Xor, we fail fast and lose errors</p></section>
            
          </div>
          <div class="presenter_notes">
            <header><h1>Presenter Notes</h1></header>
            <section>
            
            </section>
          </div>


          <footer>
            
            <aside class="source">
              Source: <a href="lecture12.md">lecture12.md</a>
            </aside>
            
            <aside class="page_number">
              52/63
            </aside>

          </footer>
        </div>
      </div>
      
      <!-- slide source: lecture12.md -->
      <div class="slide-wrapper">
        <div class="slide has_code">
          <div class="inner">
            
            
            <section><p>For example, the code below fails on the first call to parseInt and doesn’t go any further:</p>
<div class="highlight"><pre><span></span><span class="k">import</span> <span class="nn">cats.data.Xor</span>
<span class="k">def</span> <span class="n">parseInt</span><span class="o">(</span><span class="n">str</span><span class="k">:</span> <span class="kt">String</span><span class="o">)</span><span class="k">:</span> <span class="kt">String</span> <span class="kt">Xor</span> <span class="kt">Int</span> <span class="o">=</span>       
  <span class="nc">Xor</span><span class="o">.</span><span class="n">catchOnly</span><span class="o">[</span><span class="kt">NumberFormatException</span><span class="o">](</span><span class="n">str</span><span class="o">.</span><span class="n">toInt</span><span class="o">)</span>
     <span class="o">.</span><span class="n">leftMap</span><span class="o">(</span><span class="k">_</span> <span class="k">=&gt;</span> <span class="s">s&quot;Couldn&#39;t read </span><span class="si">$str</span><span class="s">&quot;</span><span class="o">)</span>
<span class="k">for</span> <span class="o">{</span>
  <span class="n">a</span> <span class="k">&lt;-</span> <span class="n">parseInt</span><span class="o">(</span><span class="s">&quot;a&quot;</span><span class="o">)</span>
  <span class="n">b</span> <span class="k">&lt;-</span> <span class="n">parseInt</span><span class="o">(</span><span class="s">&quot;b&quot;</span><span class="o">)</span>
  <span class="n">c</span> <span class="k">&lt;-</span> <span class="n">parseInt</span><span class="o">(</span><span class="s">&quot;c&quot;</span><span class="o">)</span>
<span class="o">}</span> <span class="k">yield</span> <span class="o">(</span><span class="n">a</span> <span class="o">+</span> <span class="n">b</span> <span class="o">+</span> <span class="n">c</span><span class="o">)</span>
<span class="c1">// res0: Xor[String,Int] = Left(Couldn&#39;t read a)</span>
</pre></div>
</section>
            
          </div>
          <div class="presenter_notes">
            <header><h1>Presenter Notes</h1></header>
            <section>
            
            </section>
          </div>


          <footer>
            
            <aside class="source">
              Source: <a href="lecture12.md">lecture12.md</a>
            </aside>
            
            <aside class="page_number">
              53/63
            </aside>

          </footer>
        </div>
      </div>
      
      <!-- slide source: lecture12.md -->
      <div class="slide-wrapper">
        <div class="slide">
          <div class="inner">
            
            
            <section><p>Cats provides another data type called <code>Validated</code> in addition to <code>Xor</code>.
<br />
<br />
<code>Validated</code> is an example of a non-monadic applicative.
<br />
<br />
This means Cats can provide an error-accumulating implementation of product for <code>Validated</code> without introducing inconsistent semantics.</p></section>
            
          </div>
          <div class="presenter_notes">
            <header><h1>Presenter Notes</h1></header>
            <section>
            
            </section>
          </div>


          <footer>
            
            <aside class="source">
              Source: <a href="lecture12.md">lecture12.md</a>
            </aside>
            
            <aside class="page_number">
              54/63
            </aside>

          </footer>
        </div>
      </div>
      
      <!-- slide source: lecture12.md -->
      <div class="slide-wrapper">
        <div class="slide has_code">
          <div class="inner">
            
            
            <section><p><code>Validated</code> has two subtypes, <code>Validated.Valid</code> and <code>Validated.Invalid</code>, that correspond loosely to <code>Xor.Right</code> and <code>Xor.Left</code>.</p>
<p>We can create instances directly using their apply methods:</p>
<div class="highlight"><pre><span></span><span class="k">import</span> <span class="nn">cats.data.Validated</span>
<span class="k">val</span> <span class="n">v</span> <span class="k">=</span> <span class="nc">Validated</span><span class="o">.</span><span class="nc">Valid</span><span class="o">(</span><span class="mi">123</span><span class="o">)</span>
<span class="c1">// v: cats.data.Validated.Valid[Int] = Valid(123)</span>
<span class="k">val</span> <span class="n">i</span> <span class="k">=</span> <span class="nc">Validated</span><span class="o">.</span><span class="nc">Invalid</span><span class="o">(</span><span class="s">&quot;oops&quot;</span><span class="o">)</span>
<span class="c1">// i: cats.data.Validated.Invalid[String] = Invalid(oops)</span>
</pre></div>
</section>
            
          </div>
          <div class="presenter_notes">
            <header><h1>Presenter Notes</h1></header>
            <section>
            
            </section>
          </div>


          <footer>
            
            <aside class="source">
              Source: <a href="lecture12.md">lecture12.md</a>
            </aside>
            
            <aside class="page_number">
              55/63
            </aside>

          </footer>
        </div>
      </div>
      
      <!-- slide source: lecture12.md -->
      <div class="slide-wrapper">
        <div class="slide has_code">
          <div class="inner">
            
            
            <section><p>However, it is better for type inference to use the <code>valid</code> and <code>invalid</code> smart constructors, which return a type of <code>Validated</code>:</p>
<div class="highlight"><pre><span></span><span class="k">import</span> <span class="nn">Validated.</span><span class="o">{</span><span class="n">valid</span><span class="o">,</span> <span class="n">invalid</span><span class="o">}</span>
<span class="k">val</span> <span class="n">v</span> <span class="k">=</span> <span class="n">valid</span><span class="o">[</span><span class="kt">String</span>, <span class="kt">Int</span><span class="o">](</span><span class="mi">123</span><span class="o">)</span>
<span class="c1">// v: Validated[String,Int] = Valid(123)</span>
<span class="k">val</span> <span class="n">i</span> <span class="k">=</span> <span class="n">invalid</span><span class="o">[</span><span class="kt">String</span>, <span class="kt">Int</span><span class="o">](</span><span class="s">&quot;oops&quot;</span><span class="o">)</span>
<span class="c1">// i: Validated[String,Int] = Invalid(oops)</span>
</pre></div>
</section>
            
          </div>
          <div class="presenter_notes">
            <header><h1>Presenter Notes</h1></header>
            <section>
            
            </section>
          </div>


          <footer>
            
            <aside class="source">
              Source: <a href="lecture12.md">lecture12.md</a>
            </aside>
            
            <aside class="page_number">
              56/63
            </aside>

          </footer>
        </div>
      </div>
      
      <!-- slide source: lecture12.md -->
      <div class="slide-wrapper">
        <div class="slide has_code">
          <div class="inner">
            
            
            <section><p>We can import enriched <code>valid</code> and <code>invalid</code> methods from <code>cats.syntax.validated</code> to get some syntactic sugar:</p>
<div class="highlight"><pre><span></span><span class="k">import</span> <span class="nn">cats.syntax.validated._</span>
<span class="mf">123.</span><span class="n">valid</span><span class="o">[</span><span class="kt">String</span><span class="o">]</span>
<span class="c1">//res10: Validated[String,Int] = Valid(123)</span>
<span class="s">&quot;message&quot;</span><span class="o">.</span><span class="n">invalid</span><span class="o">[</span><span class="kt">Int</span><span class="o">]</span>
<span class="c1">//res11: Validated[String,Int] = Invalid(message)</span>
</pre></div>
</section>
            
          </div>
          <div class="presenter_notes">
            <header><h1>Presenter Notes</h1></header>
            <section>
            
            </section>
          </div>


          <footer>
            
            <aside class="source">
              Source: <a href="lecture12.md">lecture12.md</a>
            </aside>
            
            <aside class="page_number">
              57/63
            </aside>

          </footer>
        </div>
      </div>
      
      <!-- slide source: lecture12.md -->
      <div class="slide-wrapper">
        <div class="slide has_code">
          <div class="inner">
            
            
            <section><div class="highlight"><pre><span></span><span class="o">(</span>
<span class="s">&quot;event 1 ok&quot;</span><span class="o">.</span><span class="n">valid</span><span class="o">[</span><span class="kt">String</span><span class="o">]</span> <span class="o">|@|</span>
<span class="s">&quot;event 2 failed!&quot;</span><span class="o">.</span><span class="n">invalid</span><span class="o">[</span><span class="kt">String</span><span class="o">]</span> <span class="o">|@|</span>
<span class="s">&quot;event 3 failed!&quot;</span><span class="o">.</span><span class="n">invalid</span><span class="o">[</span><span class="kt">String</span><span class="o">]</span>
<span class="o">)</span> <span class="n">map</span> <span class="o">{</span><span class="k">_</span> <span class="o">+</span> <span class="k">_</span> <span class="o">+</span> <span class="k">_</span><span class="o">}</span>
<span class="c1">//res12: Validated[String,String] = Invalid(event 2 failed!event 3 failed!)</span>
</pre></div>
</section>
            
          </div>
          <div class="presenter_notes">
            <header><h1>Presenter Notes</h1></header>
            <section>
            
            </section>
          </div>


          <footer>
            
            <aside class="source">
              Source: <a href="lecture12.md">lecture12.md</a>
            </aside>
            
            <aside class="page_number">
              58/63
            </aside>

          </footer>
        </div>
      </div>
      
      <!-- slide source: lecture12.md -->
      <div class="slide-wrapper">
        <div class="slide">
          <div class="inner">
            
            
            <section><p>Unlike the <code>Xor</code>’s monad, which cuts the calculation short, <code>Validated</code> keeps going to report back all failures.</p>
<p>The problem, however, is that the error messages are mushed together into one string. Shouldn’t it be something like a list?</p></section>
            
          </div>
          <div class="presenter_notes">
            <header><h1>Presenter Notes</h1></header>
            <section>
            
            </section>
          </div>


          <footer>
            
            <aside class="source">
              Source: <a href="lecture12.md">lecture12.md</a>
            </aside>
            
            <aside class="page_number">
              59/63
            </aside>

          </footer>
        </div>
      </div>
      
      <!-- slide source: lecture12.md -->
      <div class="slide-wrapper">
        <div class="slide has_code">
          <div class="inner">
            
            
            <section><div class="highlight"><pre><span></span><span class="k">import</span> <span class="nn">cats.std.list._</span>
<span class="k">import</span> <span class="nn">cats.syntax.cartesian._</span>
<span class="o">(</span>
<span class="nc">List</span><span class="o">(</span><span class="s">&quot;a&quot;</span><span class="o">).</span><span class="n">invalid</span> <span class="o">|@|</span>
<span class="nc">List</span><span class="o">(</span><span class="s">&quot;b&quot;</span><span class="o">).</span><span class="n">invalid</span>
<span class="o">).</span><span class="n">tupled</span>
<span class="c1">//res13: Validated[List[String],(Nothing, Nothing)] = Invalid(List(a, b))</span>
</pre></div>
</section>
            
          </div>
          <div class="presenter_notes">
            <header><h1>Presenter Notes</h1></header>
            <section>
            
            </section>
          </div>


          <footer>
            
            <aside class="source">
              Source: <a href="lecture12.md">lecture12.md</a>
            </aside>
            
            <aside class="page_number">
              60/63
            </aside>

          </footer>
        </div>
      </div>
      
      <!-- slide source: lecture12.md -->
      <div class="slide-wrapper">
        <div class="slide">
          <div class="inner">
            
            
            <section><p>Validated accumulates errors using a <code>Semigroup</code> (the append part of a <code>Monoid</code>).</p>
<p>This means we can use any <code>Monoid</code> as an error type, including <code>Lists</code>, <code>Vectors</code>, and <code>Strings</code>, as well as semigroups like <code>NonEmptyList</code>s.</p></section>
            
          </div>
          <div class="presenter_notes">
            <header><h1>Presenter Notes</h1></header>
            <section>
            
            </section>
          </div>


          <footer>
            
            <aside class="source">
              Source: <a href="lecture12.md">lecture12.md</a>
            </aside>
            
            <aside class="page_number">
              61/63
            </aside>

          </footer>
        </div>
      </div>
      
      <!-- slide source: lecture12.md -->
      <div class="slide-wrapper">
        <div class="slide has_code">
          <div class="inner">
            
            <header><h1>Using <code>NonEmptyList</code></h1></header>
            
            
            <section><p>Validation is one place where a <code>NonEmptyList</code> comes in handy. Think of it as a list that’s guaranteed to have at least one element.</p>
<div class="highlight"><pre><span></span><span class="k">import</span> <span class="nn">cats.data.</span><span class="o">{</span> <span class="nc">NonEmptyList</span> <span class="k">=&gt;</span> <span class="nc">NEL</span> <span class="o">}</span>
<span class="nc">NEL</span><span class="o">(</span><span class="mi">1</span><span class="o">)</span>
<span class="c1">//OneAnd[[+A]List[A],Int] = OneAnd(1,List())</span>

<span class="nc">NEL</span><span class="o">(</span><span class="mi">1</span><span class="o">)</span> <span class="o">|+|</span> <span class="nc">NEL</span><span class="o">(</span><span class="mi">1</span><span class="o">)</span>
<span class="n">res151</span><span class="k">:</span> <span class="kt">OneAnd</span><span class="o">[</span><span class="kt">List</span>,<span class="kt">Int</span><span class="o">]</span> <span class="k">=</span> <span class="nc">OneAnd</span><span class="o">(</span><span class="mi">1</span><span class="o">,</span><span class="nc">List</span><span class="o">(</span><span class="mi">1</span><span class="o">))</span>
</pre></div>
</section>
            
          </div>
          <div class="presenter_notes">
            <header><h1>Presenter Notes</h1></header>
            <section>
            
            </section>
          </div>


          <footer>
            
            <aside class="source">
              Source: <a href="lecture12.md">lecture12.md</a>
            </aside>
            
            <aside class="page_number">
              62/63
            </aside>

          </footer>
        </div>
      </div>
      
      <!-- slide source: lecture12.md -->
      <div class="slide-wrapper">
        <div class="slide has_code">
          <div class="inner">
            
            
            <section><p>A semigroup should be formed for <code>NEL[A]</code> under the <code>++</code> operation, but it’s not there by default atm, so we need to derive it from <code>SemigroupK</code>.</p>
<p>Then we can use <code>NEL[A]</code> on the invalid side to accumulate the errors:</p>
<div class="highlight"><pre><span></span><span class="k">import</span> <span class="nn">cats._</span><span class="o">,</span> <span class="n">cats</span><span class="o">.</span><span class="n">data</span><span class="o">.</span><span class="nc">Validated</span><span class="o">,</span> <span class="n">cats</span><span class="o">.</span><span class="n">std</span><span class="o">.</span><span class="n">all</span><span class="o">.</span><span class="k">_</span>
<span class="k">val</span> <span class="n">result</span> <span class="k">=</span> <span class="o">(</span>
  <span class="n">valid</span><span class="o">[</span><span class="kt">NEL</span><span class="o">[</span><span class="kt">String</span><span class="o">]</span>, <span class="kt">String</span><span class="o">](</span><span class="s">&quot;1 ok&quot;</span><span class="o">)</span> <span class="o">|@|</span>
  <span class="n">invalid</span><span class="o">[</span><span class="kt">NEL</span><span class="o">[</span><span class="kt">String</span><span class="o">]</span>, <span class="kt">String</span><span class="o">](</span><span class="nc">NEL</span><span class="o">(</span><span class="s">&quot;2 failed!&quot;</span><span class="o">))</span> <span class="o">|@|</span>
  <span class="n">invalid</span><span class="o">[</span><span class="kt">NEL</span><span class="o">[</span><span class="kt">String</span><span class="o">]</span>, <span class="kt">String</span><span class="o">](</span><span class="nc">NEL</span><span class="o">(</span><span class="s">&quot;3 failed!&quot;</span><span class="o">))</span>
<span class="o">)</span> <span class="n">map</span> <span class="o">{</span><span class="k">_</span> <span class="o">+</span> <span class="k">_</span> <span class="o">+</span> <span class="k">_</span><span class="o">}</span>
<span class="c1">//result = Invalid(OneAnd(2 failed!,List(3 failed!)))</span>
</pre></div>
</section>
            
          </div>
          <div class="presenter_notes">
            <header><h1>Presenter Notes</h1></header>
            <section>
            
            </section>
          </div>


          <footer>
            
            <aside class="source">
              Source: <a href="lecture12.md">lecture12.md</a>
            </aside>
            
            <aside class="page_number">
              63/63
            </aside>

          </footer>
        </div>
      </div>
      
      <!-- slide source:  -->
      <div class="slide-wrapper">
        <div class="slide">
          <div class="inner">
            
            
          </div>
          <div class="presenter_notes">
            <header><h1>Presenter Notes</h1></header>
            <section>
            
            </section>
          </div>


          <footer>
            
            <aside class="page_number">
              /63
            </aside>

          </footer>
        </div>
      </div>
      
    </div>
  </div>
  
  <div id="toc" class="sidebar hidden">
    <h2>Table of Contents</h2>
    <table>
      <caption>Table of Contents</caption>
      
      <tr id="toc-row-1">
        <th><a href="#slide1">Lecture 12: Applicatives</a></th>
        <td><a href="#slide1">1</a></td>
      </tr>
      
      
      <tr id="toc-row-2">
        <th><a href="#slide2">-</a></th>
        <td><a href="#slide2">2</a></td>
      </tr>
      
      
      <tr id="toc-row-3">
        <th><a href="#slide3">Apply</a></th>
        <td><a href="#slide3">3</a></td>
      </tr>
      
      
      <tr id="toc-row-4">
        <th><a href="#slide4">-</a></th>
        <td><a href="#slide4">4</a></td>
      </tr>
      
      
      <tr id="toc-row-5">
        <th><a href="#slide5">Applicative</a></th>
        <td><a href="#slide5">5</a></td>
      </tr>
      
      
      <tr id="toc-row-6">
        <th><a href="#slide6">-</a></th>
        <td><a href="#slide6">6</a></td>
      </tr>
      
      
      <tr id="toc-row-7">
        <th><a href="#slide7">-</a></th>
        <td><a href="#slide7">7</a></td>
      </tr>
      
      
      <tr id="toc-row-8">
        <th><a href="#slide8">-</a></th>
        <td><a href="#slide8">8</a></td>
      </tr>
      
      
      <tr id="toc-row-9">
        <th><a href="#slide9">-</a></th>
        <td><a href="#slide9">9</a></td>
      </tr>
      
      
      <tr id="toc-row-10">
        <th><a href="#slide10">-</a></th>
        <td><a href="#slide10">10</a></td>
      </tr>
      
      
      <tr id="toc-row-11">
        <th><a href="#slide11">-</a></th>
        <td><a href="#slide11">11</a></td>
      </tr>
      
      
      <tr id="toc-row-12">
        <th><a href="#slide12">-</a></th>
        <td><a href="#slide12">12</a></td>
      </tr>
      
      
      <tr id="toc-row-13">
        <th><a href="#slide13">-</a></th>
        <td><a href="#slide13">13</a></td>
      </tr>
      
      
      <tr id="toc-row-14">
        <th><a href="#slide14">Type Class Hierarchy</a></th>
        <td><a href="#slide14">14</a></td>
      </tr>
      
      
      <tr id="toc-row-15">
        <th><a href="#slide15">-</a></th>
        <td><a href="#slide15">15</a></td>
      </tr>
      
      
      <tr id="toc-row-16">
        <th><a href="#slide16">-</a></th>
        <td><a href="#slide16">16</a></td>
      </tr>
      
      
      <tr id="toc-row-17">
        <th><a href="#slide17">-</a></th>
        <td><a href="#slide17">17</a></td>
      </tr>
      
      
      <tr id="toc-row-18">
        <th><a href="#slide18">Cartsian</a></th>
        <td><a href="#slide18">18</a></td>
      </tr>
      
      
      <tr id="toc-row-19">
        <th><a href="#slide19">-</a></th>
        <td><a href="#slide19">19</a></td>
      </tr>
      
      
      <tr id="toc-row-20">
        <th><a href="#slide20">-</a></th>
        <td><a href="#slide20">20</a></td>
      </tr>
      
      
      <tr id="toc-row-21">
        <th><a href="#slide21">-</a></th>
        <td><a href="#slide21">21</a></td>
      </tr>
      
      
      <tr id="toc-row-22">
        <th><a href="#slide22">-</a></th>
        <td><a href="#slide22">22</a></td>
      </tr>
      
      
      <tr id="toc-row-23">
        <th><a href="#slide23">-</a></th>
        <td><a href="#slide23">23</a></td>
      </tr>
      
      
      <tr id="toc-row-24">
        <th><a href="#slide24">-</a></th>
        <td><a href="#slide24">24</a></td>
      </tr>
      
      
      <tr id="toc-row-25">
        <th><a href="#slide25">Applicative laws</a></th>
        <td><a href="#slide25">25</a></td>
      </tr>
      
      
      <tr id="toc-row-26">
        <th><a href="#slide26">-</a></th>
        <td><a href="#slide26">26</a></td>
      </tr>
      
      
      <tr id="toc-row-27">
        <th><a href="#slide27">Identity</a></th>
        <td><a href="#slide27">27</a></td>
      </tr>
      
      
      <tr id="toc-row-28">
        <th><a href="#slide28">Composition</a></th>
        <td><a href="#slide28">28</a></td>
      </tr>
      
      
      <tr id="toc-row-29">
        <th><a href="#slide29">-</a></th>
        <td><a href="#slide29">29</a></td>
      </tr>
      
      
      <tr id="toc-row-30">
        <th><a href="#slide30">Homomorphism</a></th>
        <td><a href="#slide30">30</a></td>
      </tr>
      
      
      <tr id="toc-row-31">
        <th><a href="#slide31">-</a></th>
        <td><a href="#slide31">31</a></td>
      </tr>
      
      
      <tr id="toc-row-32">
        <th><a href="#slide32">Interchange</a></th>
        <td><a href="#slide32">32</a></td>
      </tr>
      
      
      <tr id="toc-row-33">
        <th><a href="#slide33">-</a></th>
        <td><a href="#slide33">33</a></td>
      </tr>
      
      
      <tr id="toc-row-34">
        <th><a href="#slide34">-</a></th>
        <td><a href="#slide34">34</a></td>
      </tr>
      
      
      <tr id="toc-row-35">
        <th><a href="#slide35">-</a></th>
        <td><a href="#slide35">35</a></td>
      </tr>
      
      
      <tr id="toc-row-36">
        <th><a href="#slide36">Monads vs Applicatives</a></th>
        <td><a href="#slide36">36</a></td>
      </tr>
      
      
      <tr id="toc-row-37">
        <th><a href="#slide37">-</a></th>
        <td><a href="#slide37">37</a></td>
      </tr>
      
      
      <tr id="toc-row-38">
        <th><a href="#slide38">-</a></th>
        <td><a href="#slide38">38</a></td>
      </tr>
      
      
      <tr id="toc-row-39">
        <th><a href="#slide39">-</a></th>
        <td><a href="#slide39">39</a></td>
      </tr>
      
      
      <tr id="toc-row-40">
        <th><a href="#slide40">-</a></th>
        <td><a href="#slide40">40</a></td>
      </tr>
      
      
      <tr id="toc-row-41">
        <th><a href="#slide41">-</a></th>
        <td><a href="#slide41">41</a></td>
      </tr>
      
      
      <tr id="toc-row-42">
        <th><a href="#slide42">-</a></th>
        <td><a href="#slide42">42</a></td>
      </tr>
      
      
      <tr id="toc-row-43">
        <th><a href="#slide43">-</a></th>
        <td><a href="#slide43">43</a></td>
      </tr>
      
      
      <tr id="toc-row-44">
        <th><a href="#slide44">-</a></th>
        <td><a href="#slide44">44</a></td>
      </tr>
      
      
      <tr id="toc-row-45">
        <th><a href="#slide45">-</a></th>
        <td><a href="#slide45">45</a></td>
      </tr>
      
      
      <tr id="toc-row-46">
        <th><a href="#slide46">Example: Futures</a></th>
        <td><a href="#slide46">46</a></td>
      </tr>
      
      
      <tr id="toc-row-47">
        <th><a href="#slide47">-</a></th>
        <td><a href="#slide47">47</a></td>
      </tr>
      
      
      <tr id="toc-row-48">
        <th><a href="#slide48">-</a></th>
        <td><a href="#slide48">48</a></td>
      </tr>
      
      
      <tr id="toc-row-49">
        <th><a href="#slide49">-</a></th>
        <td><a href="#slide49">49</a></td>
      </tr>
      
      
      <tr id="toc-row-50">
        <th><a href="#slide50">Example: Validated</a></th>
        <td><a href="#slide50">50</a></td>
      </tr>
      
      
      <tr id="toc-row-51">
        <th><a href="#slide51">-</a></th>
        <td><a href="#slide51">51</a></td>
      </tr>
      
      
      <tr id="toc-row-52">
        <th><a href="#slide52">-</a></th>
        <td><a href="#slide52">52</a></td>
      </tr>
      
      
      <tr id="toc-row-53">
        <th><a href="#slide53">-</a></th>
        <td><a href="#slide53">53</a></td>
      </tr>
      
      
      <tr id="toc-row-54">
        <th><a href="#slide54">-</a></th>
        <td><a href="#slide54">54</a></td>
      </tr>
      
      
      <tr id="toc-row-55">
        <th><a href="#slide55">-</a></th>
        <td><a href="#slide55">55</a></td>
      </tr>
      
      
      <tr id="toc-row-56">
        <th><a href="#slide56">-</a></th>
        <td><a href="#slide56">56</a></td>
      </tr>
      
      
      <tr id="toc-row-57">
        <th><a href="#slide57">-</a></th>
        <td><a href="#slide57">57</a></td>
      </tr>
      
      
      <tr id="toc-row-58">
        <th><a href="#slide58">-</a></th>
        <td><a href="#slide58">58</a></td>
      </tr>
      
      
      <tr id="toc-row-59">
        <th><a href="#slide59">-</a></th>
        <td><a href="#slide59">59</a></td>
      </tr>
      
      
      <tr id="toc-row-60">
        <th><a href="#slide60">-</a></th>
        <td><a href="#slide60">60</a></td>
      </tr>
      
      
      <tr id="toc-row-61">
        <th><a href="#slide61">-</a></th>
        <td><a href="#slide61">61</a></td>
      </tr>
      
      
      <tr id="toc-row-62">
        <th><a href="#slide62">Using <code>NonEmptyList</code></a></th>
        <td><a href="#slide62">62</a></td>
      </tr>
      
      
      <tr id="toc-row-63">
        <th><a href="#slide63">-</a></th>
        <td><a href="#slide63">63</a></td>
      </tr>
      
      
    </table>
  </div>
  
  <div id="help" class="sidebar hidden">
    <h2>Help</h2>
    <table>
      <caption>Help</caption>
      <tr>
        <th>Table of Contents</th>
        <td>t</td>
      </tr>
      <tr>
        <th>Exposé</th>
        <td>ESC</td>
      </tr>
      <tr>
        <th>Full screen slides</th>
        <td>e</td>
      </tr>
      <tr>
        <th>Presenter View</th>
        <td>p</td>
      </tr>
      <tr>
        <th>Source Files</th>
        <td>s</td>
      </tr>
      <tr>
        <th>Slide Numbers</th>
        <td>n</td>
      </tr>
      <tr>
        <th>Toggle screen blanking</th>
        <td>b</td>
      </tr>
      <tr>
        <th>Show/hide slide context</th>
        <td>c</td>
      </tr>
      <tr>
        <th>Notes</th>
        <td>2</td>
      </tr>
      <tr>
        <th>Help</th>
        <td>h</td>
      </tr>
    </table>
  </div>
  <script>main()</script>
</body>
</html>