MX Reveal: Student Meetup #6

<h1 id="monad-stacking">Monad Stacking</h1>

<h4 id="learning-to-read-and-write">Learning to read <strong>and</strong> write</h4>

<h2 id="quick-refresher">Quick refresher</h2>

<h3 id="monads-as-actions-in-a-context">Monads as actions in a context</h3>

<pre><code class="language-haskell"
           >-- Maybe Int
dropState      = \ x -&gt; Nothing
incrementState = \ x -&gt; Just (x + 2)
replaceState   = \ x -&gt; Just 5</code></pre>

<pre><code class="language-haskell"
           data-line-numbers="1-2|4-5|7|9-10|">&gt; (Just 4) &gt;&gt;= dropState
Nothing

&gt; (Just 4) &gt;&gt;= incrementState &gt;&gt;= incrementState
Just 8

&gt; combined = incrementState &gt;=&gt; incrementState &gt;=&gt; incrementState

&gt; (Just 4) &gt;&gt;= combined
Just 10</code></pre>



<h3 id="monads-as-side-effects">Monads as side-effects</h3>


<h3 id="examples">Examples</h3>

<pre><code class="language-haskell"
           >teller :: W.Writer [String] Int
teller = do
  W.tell [&quot;Log msg #1&quot;]
  W.tell [&quot;Log msg #1&quot;]
  return 0</code></pre>

<pre><code class="language-haskell"
           >stater :: S.State Int String
stater = do
  x &lt;- S.get
  S.put 40
  return $ show x</code></pre>

<pre><code class="language-haskell"
           >errorer :: E.Except String Int
errorer = E.throwError &quot;OH NO!&quot;</code></pre>

<pre><code class="language-haskell"
           >together :: &lt;secret&gt;
together = do
  x &lt;- S.get
  W.tell [x]
  S.put 40
  return x</code></pre>

<pre><code class="language-haskell"
           >together :: ??? W.MonadWriter Int ???
together = do
  x &lt;- S.get -- error
  W.tell [x]
  S.put 40 -- error
  return x</code></pre>

<pre><code class="language-haskell"
           >together :: ??? S.MonadState ???
together = do
  x &lt;- S.get
  W.tell [x] -- error
  S.put 40
  return x</code></pre>

<pre><code class="language-haskell"
           >together :: (W.MonadWriter [Int] m, S.MonadState Int m) =&gt; m Int
together = do
  x &lt;- S.get
  W.tell [x]
  S.put 40
  return x</code></pre>

<pre><code class="language-haskell"
           >callN :: (Monad m) =&gt; m Int

call1 = S.execStateT (W.execWriterT together) 0

call2 = W.execWriterT (S.execStateT together 0)</code></pre>


<h1 id="what-is-this-mystery-monad">What is this mystery monad?</h1>


<h1 id="why-can-state-act-as-a-writer">Why can State act as a Writer ?!?!?</h1>

<pre><code class="language-haskell"
           >-- Taken directly from the mtl sources
instance MonadWriter w m =&gt; MonadWriter w (ExceptT e m) where
    writer = lift . writer
    tell   = lift . tell
    listen = Except.liftListen listen
    pass   = Except.liftPass pass

instance MonadWriter w m =&gt; MonadWriter w (IdentityT m) where
    writer = lift . writer
    tell   = lift . tell
    listen = Identity.mapIdentityT listen
    pass   = Identity.mapIdentityT pass

instance MonadWriter w m =&gt; MonadWriter w (MaybeT m) where
    writer = lift . writer
    tell   = lift . tell
    listen = Maybe.liftListen listen
    pass   = Maybe.liftPass pass

instance MonadWriter w m =&gt; MonadWriter w (ReaderT r m) where
    writer = lift . writer
    tell   = lift . tell
    listen = mapReaderT listen
    pass   = mapReaderT pass</code></pre>


<h1 id="the-n2-instances-problem">“The n² Instances Problem”</h1>


<h1 id="one-of-the-many-attempts-at-a-solution">One of the many attempts at a solution:</h1>



<h1 id="polysemy"><em>Polysemy</em></h1>
<h2 id="monads-as-dsls">Monads as DSLs</h2>


<h2 id="dsl">DSL:</h2>

<pre><code class="language-haskell"
           >data Semaphore = Red | Green | Blue</code></pre>
<h2 id="interpreter">Interpreter:</h2>

<pre><code class="language-haskell"
           >\case
  Red   -&gt; print &quot;Gone Red&quot;
  Green -&gt; print &quot;Gone Green&quot;
  Blue  -&gt; return 0</code></pre>

<h2 id="program">Program:</h2>

<pre><code class="language-haskell"
           >do red
   red
   green
   x &lt;- blue
   print x</code></pre>

<pre><code class="language-haskell"
           >data Semaphore = Red | Green | Blue
data Human = Eat | Sleep
data ProgTest = Finish | Cry</code></pre>

<pre><code class="language-haskell"
           >do red
   cry
   eat
   sleep
   finish</code></pre>


<h2 id="tangent-1">Tangent #1:</h2>
<h1 id="datakinds">DataKinds</h1>


<h2 id="tangent-2">Tangent #2:</h2>
<h1 id="what-are-kinds">What are Kinds???</h1>

<h2 id="tangent-3">Tangent #3:</h2>
<h1 id="type-families">Type Families</h1>

<pre><code class="language-haskell"
           >class Foo where
  bar :: Int -&gt; Int

instance Foo where
  bar x = x + 1</code></pre>

<pre><code class="language-haskell"
           >type family F a where
  F Int = Bool
  F String = Int</code></pre>

<pre><code class="language-haskell"
           >ghci&gt; 4 :: F String
4
ghci&gt; 4 :: F Int

&lt;interactive&gt;:35:1: error: [GHC-39999]
    • No instance for ‘Num Bool’ arising from the literal ‘4’
    • In the expression: 4 :: F Int
      In an equation for ‘it’: it = 4 :: F Int</code></pre>


<h3 id="why-do-datakinds-help">Why do DataKinds help?</h3>

<pre><code class="language-haskell"
           >type family First a where
  First (x &#x27;: xs) = x</code></pre>

<pre><code class="language-haskell"
           >ghci&gt; (&quot;l&quot; :: F &#x27;[String, Bool])
&quot;l&quot;
ghci&gt; (&quot;l&quot; :: F &#x27;[String, Int])
&quot;l&quot;
ghci&gt; (&quot;l&quot; :: F &#x27;[Int])

&lt;interactive&gt;:31:2: error: [GHC-83865]
    • Couldn&#x27;t match type ‘[Char]’ with ‘Int’
      Expected: F &#x27;[Int]
        Actual: String
    • In the expression: &quot;l&quot; :: F &#x27;[Int]
      In an equation for ‘it’: it = (&quot;l&quot; :: F &#x27;[Int])</code></pre>


<h2 id="our-magic-monad">Our Magic Monad:</h2>
<h1 id="sem-r-a"><strong>Sem r a</strong></h1>

<pre><code class="language-haskell"
           >Sem
  r -- DataKind Monad Stack
  a -- Return Type</code></pre>

<h1 id="sem-int"><strong>Sem '[] Int</strong></h1>

<h2 id="leaving">Leaving?</h2>
<ol>
<li>No effects left</li>
<li>One known Monadic effect left</li>
</ol>

<pre><code class="language-haskell"
           data-line-numbers="1-2|">semFive :: Sem &#x27;[] Int
semFive = return 5

run semFive
&gt; 5</code></pre>

<pre><code class="language-haskell"
           >Sem [] Int -- issue ?</code></pre>
<ul>
<li>
<p>Expecting one more argument to ‘[]’</p>
<p>Expected kind ‘*’, but ‘[]’ has kind ‘* -&gt; *’</p>
</li>
<li>
<p>In the first argument of ‘Sem’, namely ‘[]’</p>
<p>In an expression type signature: Sem [] Int</p>
</li>
</ul>

<pre><code class="language-haskell"
           data-line-numbers="1|2-4|">semList :: Sem &#x27;[Embed []] Int
semList = do x &lt;- embed [1, 2]
			 y &lt;- embed [3, 4]
			 return $ x + y

runM semList
&gt; 5</code></pre>

<h2 id="member-lang1-r-sem-r-int"><code>Member Lang1 r =&gt; Sem r Int</code></h2>

<p>How? TypeFamilies</p>

<h4 id="surprisingly-important">Surprisingly important</h4>
<p>(<code>Sem '[A, B] a</code>) != (<code>Sem '[B, A] a</code>)</p>

<p>Yet:</p>
<p><code>Member A '[B, A]</code></p>
<p><code>Member B '[B, A]</code></p>
<p>and</p>
<p><code>Members '[A, B] '[B, A]</code></p>
<p><code>Members '[B, A] '[B, A]</code></p>

<h2 id="defers-specifying-order">Defers specifying order</h2>

<h2 id="now-for-the-full-code">Now for the full code</h2>

<h3 id="gadt">GADT</h3>

<pre><code class="language-haskell"
           >data       Semaphore m a
 where
  Red   :: Semaphore m ()
  Green :: Semaphore m ()
  Blue	:: Semaphore m Int</code></pre>

<h3 id="generate-verbs">Generate verbs</h3>

<pre><code class="language-haskell"
           >makeSem &#x27;&#x27;Semaphore</code></pre>
<p>Creates <code>red</code>, <code>green</code>, <code>blue</code>
from <code>Red</code>, <code>Green</code>, <code>Blue</code></p>

<pre><code class="language-haskell"
           data-line-numbers="|1-2|3-7|">semaphoreInterpreter ::
  Member (Embed IO) r =&gt; Sem (Semaphore : r) a -&gt; Sem r a
semaphoreInterpreter = interpret $
  \case
    Red   -&gt; embed $ print &quot;Gone Red&quot;
    Green -&gt; embed $ print &quot;Gone Green&quot;
    Blue  -&gt; return 5</code></pre>

<pre><code class="language-haskell"
           >prog = do red
		  red
		  green
		  x &lt;- blue
		  return $ x * 2</code></pre>

<p>
<pre><code class="language-haskell"
           >prog</code></pre>

<code>:: Members [Semaphore, Embed IO] r =&gt; Sem r Int</code></p>

<p>
<pre><code class="language-haskell"
           >prog
&amp; semaphoreinterpreter</code></pre>

<code>:: Members [Embed IO] r =&gt; Sem r Int</code></p>

<p>
<pre><code class="language-haskell"
           >prog
&amp; semaphoreinterpreter
&amp; runM</code></pre>

<code>:: IO Int</code></p>

<blockquote>
<p>"Gone Red"</p>
<p>"Gone Red"</p>
<p>"Gone Green"</p>
<p>10</p>
</blockquote>

<pre><code class="language-haskell"
           >prog :: Members &#x27;[Human, Semaphore] r =&gt; Sem r Int
prog = do red
		  red
		  green
		  cry
		  x &lt;- blue
		  return $ x * 2</code></pre>

<pre><code class="language-haskell"
           >prog
&amp; interpretHuman
&amp; interpretSemaphore
&amp; runM</code></pre>

<pre><code class="language-haskell"
           >prog
&amp; interpretSemaphore
&amp; interpretHuman
&amp; runM</code></pre>

<pre><code class="language-plaintext"
           >• Could not deduce ‘Member Human r’
	arising from a use of ‘...’</code></pre>

<h3 id="i-just-scratched-the-surface-however">I just scratched the surface, however ...</h3>
<ul>
<li>Higher-order effects</li>
<li>Tagged effects</li>
</ul>

<h3 id="dekuju-za-porornost">Děkuju za porornost</h3>
<h1 id="otazky">Otázky?</h1>