-
Notifications
You must be signed in to change notification settings - Fork 0
/
Copy pathindex.html
executable file
·411 lines (385 loc) · 33.8 KB
/
index.html
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
<!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Applicatives, Alternative, and Aeson</title>
<meta name="description" content="Applicatives, Alternative, and Aeson">
<meta name="author" content="Levi Schuck" />
<meta name="apple-mobile-web-app-capable" content="yes" />
<meta name="apple-mobile-web-app-status-bar-style" content="black-translucent" />
<meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no">
<link rel="stylesheet" href="reveal.js/css/reveal.css">
<link rel="stylesheet" href="reveal.js/css/theme/black.css" id="theme">
<!-- For syntax highlighting -->
<link rel="stylesheet" href="reveal.js/lib/css/zenburn.css">
<!-- If the query includes 'print-pdf', use the PDF print sheet -->
<script>
document.write( '<link rel="stylesheet" href="reveal.js/css/print/' +
( window.location.search.match( /print-pdf/gi ) ? 'pdf' : 'paper' ) +
'.css" type="text/css" media="print">' );
</script>
<!--[if lt IE 9]>
<script src="lib/js/html5shiv.js"></script>
<![endif]-->
</head>
<body>
<div class="reveal">
<!-- Any section element inside of this container is displayed as a slide -->
<div class="slides">
<section>
<h1>Applicatives, Alternative, and Aeson</h1>
<h3>Levi Schuck</h3>
<p>
<h4>March 3, 2015</h4>
</p>
</section>
<section id="currying" class="level1">
<h1>Currying</h1>
<section id="brief-intro-reminder" class="level2">
<h2>Brief intro / reminder</h2>
<p>It's hard to talk about applicatives if we don't talk about how functions are <em>applied</em>.</p>
</section>
<section id="not-that-curry." class="level2">
<h2>Not that curry.</h2>
<figure>
<img src="images/curry.jpg" />
</figure>
</section>
<section id="maybe-this-one" class="level2">
<h2>Maybe this one?</h2>
<figure>
<img src="images/math-curry.png" />
</figure>
<p>Well, it's kinda mathy..</p>
</section>
<section id="haskell-example" class="level2">
<h2>Haskell example</h2>
<p>Let's try a Haskell syntax approach.</p>
<pre class="sourceCode haskell"><code class="sourceCode haskell">append x y <span class="fu">=</span> x <span class="fu">++</span> y</code></pre>
<p>Let's start with http</p>
<pre class="sourceCode haskell"><code class="sourceCode haskell">http x <span class="fu">=</span> <span class="st">"http://"</span> <span class="fu">++</span> x</code></pre>
</section>
<section id="but-we-can-do-better" class="level2">
<h2>But we can do better!</h2>
<pre class="sourceCode haskell"><code class="sourceCode haskell">append x y <span class="fu">=</span> x <span class="fu">++</span> y</code></pre>
<p>What if.. we rewrite this function.</p>
<pre class="sourceCode haskell"><code class="sourceCode haskell">http x <span class="fu">=</span> append <span class="st">"http://"</span> x</code></pre>
<p>Okay, but where does currying come in?</p>
</section>
<section id="currying-http" class="level2">
<h2>Currying http</h2>
<p>So, with the following:</p>
<pre class="sourceCode haskell"><code class="sourceCode haskell">append x y <span class="fu">=</span> x <span class="fu">++</span> y
http x <span class="fu">=</span> append <span class="st">"http://"</span> x</code></pre>
<p>We could rewrite http to be infinitesimally shorter!</p>
<pre class="sourceCode haskell"><code class="sourceCode haskell">append x y <span class="fu">=</span> x <span class="fu">++</span> y
http <span class="fu">=</span> append <span class="st">"http://"</span></code></pre>
</section>
<section id="where-did-the-x-go" class="level2">
<h2>Where did the <code>x</code> go?</h2>
<figure>
<img src="images/massimo.jpg" />
</figure>
<pre class="sourceCode haskell"><code class="sourceCode haskell">http <span class="fu">=</span> append <span class="st">"http://"</span></code></pre>
</section>
<section id="the-types-are-still-the-same" class="level2">
<h2>The types are still the same</h2>
<pre class="sourceCode haskell"><code class="sourceCode haskell">http x <span class="fu">=</span> append <span class="st">"http://"</span> x
<span class="ot">http ::</span> [<span class="dt">Char</span>] <span class="ot">-></span> [<span class="dt">Char</span>]
http' <span class="fu">=</span> append <span class="st">"http://"</span>
<span class="ot">http' ::</span> [<span class="dt">Char</span>] <span class="ot">-></span> [<span class="dt">Char</span>]</code></pre>
<p>We didn't specify the parameter x, yet the type still takes something.</p>
<p><strong>Currying!</strong></p>
</section>
<section id="functions-of-x-on-the-wall-99-functions-of-x.-take-one-down-pass-it-around-98-functions-of-x-on-the-wall." class="level2">
<h2>99 functions of x on the wall, 99 functions of x. Take one down, pass it around, 98 functions of x on the wall.</h2>
<p>So, applying a parameter cuts the remaining parameters on the type</p>
<pre class="sourceCode haskell"><code class="sourceCode haskell"><span class="ot">append ::</span> [a] <span class="ot">-></span> [a] <span class="ot">-></span> [a]
append <span class="st">"http://"</span><span class="ot"> ::</span> [<span class="dt">Char</span>] <span class="ot">-></span> [<span class="dt">Char</span>]
append <span class="st">"http://"</span> <span class="st">"google.com"</span><span class="ot"> ::</span> [<span class="dt">Char</span>]</code></pre>
</section>
<section id="but-back-to-currying" class="level2">
<h2>But back to currying</h2>
<p>So, we have established that by applying one parameter to a two-parameter function, we are left with a one parameter function.</p>
<p>Haskell lets us skip parameters in our declaration if the types match up on the tail of the type.</p>
</section>
</section>
<section id="applicative" class="level1">
<h1>Applicative</h1>
<section id="whats-an-ap..-ap...-applicative" class="level2">
<h2>What's an ap.. ap... applicative?</h2>
<pre class="sourceCode haskell"><code class="sourceCode haskell"><span class="kw">class</span> (<span class="dt">Functor</span> f) <span class="ot">=></span> <span class="dt">Applicative</span> f <span class="kw">where</span>
<span class="ot"> pure ::</span> a <span class="ot">-></span> f a
<span class="ot"> (<*>) ::</span> f (a <span class="ot">-></span> b) <span class="ot">-></span> f a <span class="ot">-></span> f b</code></pre>
<ul>
<li><code>pure</code> lifts a value into the context of the Applicative functor.</li>
<li><code><*></code> takes a functor of a function, a functor with a value, then applies the first function to the given value, and results in whatever the function decides.</li>
</ul>
</section>
<section id="lets-start-with-maybe" class="level2">
<h2>Let's start with Maybe</h2>
<p>(Not the official implementation, but similar)</p>
<pre class="sourceCode haskell"><code class="sourceCode haskell"><span class="kw">instance</span> <span class="dt">Applicative</span> <span class="dt">Maybe</span> <span class="kw">where</span>
pure x <span class="fu">=</span> <span class="dt">Just</span> x
<span class="dt">Nothing</span> <span class="fu"><*></span> _ <span class="fu">=</span> <span class="dt">Nothing</span>
_ <span class="fu"><*></span> <span class="dt">Nothing</span> <span class="fu">=</span> <span class="dt">Nothing</span>
<span class="dt">Just</span> x <span class="fu"><*></span> <span class="dt">Just</span> y <span class="fu">=</span> <span class="dt">Just</span> (x y)</code></pre>
</section>
<section id="example-program" class="level2">
<h2>Example program</h2>
<pre class="sourceCode haskell"><code class="sourceCode haskell">main <span class="fu">=</span> <span class="kw">do</span> <span class="co">-- λ> main</span>
putStr <span class="st">"a: "</span> <span class="co">-- a: 1</span>
a' <span class="ot"><-</span> getLine <span class="co">-- b: 2</span>
<span class="kw">let</span> a <span class="fu">=</span> readMaybe<span class="ot"> a' ::</span> <span class="dt">Maybe</span> <span class="dt">Int</span> <span class="co">-- c: Just (1,2)</span>
putStr <span class="st">"b: "</span> <span class="co">-- λ> main</span>
b' <span class="ot"><-</span> getLine <span class="co">-- a: Nope</span>
<span class="kw">let</span> b <span class="fu">=</span> readMaybe<span class="ot"> b' ::</span> <span class="dt">Maybe</span> <span class="dt">Int</span> <span class="co">-- b: 4</span>
<span class="kw">let</span> c <span class="fu">=</span> pure (,) <span class="fu"><*></span> a <span class="fu"><*></span> b <span class="co">-- c: Nothing</span>
putStr <span class="st">"c: "</span> <span class="co">-- λ> main</span>
putStrLn <span class="fu">$</span> show c <span class="co">-- a: 2</span>
<span class="co">-- b: Nope</span>
<span class="co">-- c: Nothing</span></code></pre>
</section>
<section id="what-about-the-fabeled" class="level2">
<h2>What about the fabeled <code><$></code></h2>
<p>It's actually just <code>fmap</code> from functor.</p>
<p>What does <code>Maybe</code>'s <code>fmap</code> look like?</p>
<pre class="sourceCode haskell"><code class="sourceCode haskell"><span class="kw">instance</span> <span class="dt">Functor</span> <span class="dt">Maybe</span> <span class="kw">where</span>
fmap _ <span class="dt">Nothing</span> <span class="fu">=</span> <span class="dt">Nothing</span>
fmap f (<span class="dt">Just</span> a) <span class="fu">=</span> <span class="dt">Just</span> (f a)</code></pre>
<p>Remember when we used pure?</p>
<pre class="sourceCode haskell"><code class="sourceCode haskell"><span class="kw">let</span> c <span class="fu">=</span> pure (,) <span class="fu"><*></span> a <span class="fu"><*></span> b
<span class="co">-- It can be rewritten as</span>
<span class="kw">let</span> c <span class="fu">=</span> (,) <span class="fu"><$></span> a <span class="fu"><*></span> b</code></pre>
</section>
<section id="lets-step-through-this" class="level2">
<h2>Let's step through this</h2>
<pre class="sourceCode haskell"><code class="sourceCode haskell"><span class="kw">let</span> a <span class="fu">=</span> <span class="dt">Just</span> <span class="dv">1</span>
b <span class="fu">=</span> <span class="dt">Just</span> <span class="dv">2</span>
c <span class="fu">=</span> (,) <span class="fu"><$></span> a <span class="fu"><*></span> b
c <span class="fu">=</span> <span class="dt">Just</span> (<span class="dv">1</span>,) <span class="fu"><*></span> b
c <span class="fu">=</span> <span class="dt">Just</span> (<span class="dv">1</span>,<span class="dv">2</span>)</code></pre>
<pre class="sourceCode haskell"><code class="sourceCode haskell"><span class="kw">let</span> a <span class="fu">=</span> <span class="dt">Nothing</span>
b <span class="fu">=</span> <span class="dt">Just</span> <span class="dv">4</span>
c <span class="fu">=</span> (,) <span class="fu"><$></span> a <span class="fu"><*></span> b
c <span class="fu">=</span> <span class="dt">Nothing</span> <span class="fu"><*></span> b
c <span class="fu">=</span> <span class="dt">Nothing</span></code></pre>
<pre class="sourceCode haskell"><code class="sourceCode haskell"><span class="kw">let</span> a <span class="fu">=</span> <span class="dt">Just</span> <span class="dv">4</span>
b <span class="fu">=</span> <span class="dt">Nothing</span>
c <span class="fu">=</span> (,) <span class="fu"><$></span> a <span class="fu"><*></span> b
c <span class="fu">=</span> <span class="dt">Just</span> (<span class="dv">4</span>,) <span class="fu"><*></span> b
c <span class="fu">=</span> <span class="dt">Nothing</span></code></pre>
</section>
<section id="or..-really-more-like" class="level2">
<h2>Or.. really more like</h2>
<pre class="sourceCode haskell"><code class="sourceCode haskell"><span class="kw">let</span> a <span class="fu">=</span> <span class="dt">Just</span> <span class="dv">1</span>
b <span class="fu">=</span> <span class="dt">Just</span> <span class="dv">2</span>
(,) <span class="fu">=</span> \x <span class="ot">-></span> \y <span class="ot">-></span> (x,y)
c <span class="fu">=</span> (,) <span class="fu"><$></span> a <span class="fu"><*></span> b
c <span class="fu">=</span> (,) <span class="fu"><$></span> <span class="dt">Just</span> <span class="dv">1</span> <span class="fu"><*></span> <span class="dt">Just</span> <span class="dv">2</span>
c <span class="fu">=</span> <span class="dt">Just</span> (<span class="kw">let</span> x <span class="fu">=</span> <span class="dv">1</span> <span class="kw">in</span> \y <span class="ot">-></span> (x,y)) <span class="fu"><*></span> <span class="dt">Just</span> <span class="dv">2</span>
c <span class="fu">=</span> <span class="dt">Just</span> (<span class="kw">let</span> x <span class="fu">=</span> <span class="dv">1</span>
y <span class="fu">=</span> <span class="dv">2</span> <span class="kw">in</span> (x,y))
c <span class="fu">=</span> <span class="dt">Just</span> (<span class="dv">1</span>,<span class="dv">2</span>)</code></pre>
</section>
</section>
<section id="alternative" class="level1">
<h1>Alternative</h1>
<section id="typeclass-definition" class="level2">
<h2>Typeclass definition</h2>
<p>With this, we have the ability to take the first thing that works.</p>
<pre class="sourceCode haskell"><code class="sourceCode haskell"><span class="kw">class</span> <span class="dt">Applicative</span> f <span class="ot">=></span> <span class="dt">Alternative</span> f <span class="kw">where</span>
<span class="co">-- | The identity of '<|>'</span>
<span class="ot"> empty ::</span> f a
<span class="co">-- | An associative binary operation</span>
<span class="ot"> (<|>) ::</span> f a <span class="ot">-></span> f a <span class="ot">-></span> f a
<span class="kw">instance</span> <span class="dt">Alternative</span> <span class="dt">Maybe</span> <span class="kw">where</span>
empty <span class="fu">=</span> <span class="dt">Nothing</span>
<span class="dt">Nothing</span> <span class="fu"><|></span> right <span class="fu">=</span> right
left <span class="fu"><|></span> _ <span class="fu">=</span> left</code></pre>
<p>Which is to say "if we don't have anything yet, try the next thing"</p>
</section>
<section id="blunt-example" class="level2">
<h2>Blunt example</h2>
<pre class="sourceCode haskell"><code class="sourceCode haskell">example <span class="fu">=</span> <span class="dt">Nothing</span> <span class="fu"><|></span> <span class="dt">Just</span> <span class="dv">3</span> <span class="fu"><|></span> <span class="dt">Nothing</span> <span class="fu"><|></span> <span class="dt">Just</span> <span class="dv">2</span> <span class="fu"><|></span> <span class="dt">Just</span> <span class="dv">1</span>
example <span class="fu">=</span> <span class="dt">Just</span> <span class="dv">3</span></code></pre>
</section>
<section id="repeat-a-b-c" class="level2">
<h2>Repeat a, b, c</h2>
<pre class="sourceCode haskell"><code class="sourceCode haskell">main <span class="fu">=</span> <span class="kw">do</span>
putStr <span class="st">"a: "</span>
a' <span class="ot"><-</span> getLine
<span class="kw">let</span> a <span class="fu">=</span> readMaybe<span class="ot"> a' ::</span> <span class="dt">Maybe</span> <span class="dt">Int</span>
putStr <span class="st">"b: "</span>
b' <span class="ot"><-</span> getLine
<span class="kw">let</span> b <span class="fu">=</span> readMaybe<span class="ot"> b' ::</span> <span class="dt">Maybe</span> <span class="dt">Int</span>
<span class="kw">let</span> c <span class="fu">=</span> a <span class="fu"><|></span> empty <span class="fu"><|></span> b
putStr <span class="st">"c: "</span>
putStrLn <span class="fu">$</span> show c</code></pre>
<ul>
<li>When <code>a</code> is <code>Just 1</code>, no matter what <code>b</code> is, <code>c</code> is <code>Just 1</code>.</li>
<li>When <code>a</code> is <code>Nothing</code>, and <code>b</code> is <code>Just 2</code>, <code>c</code> is <code>Just 2</code>.</li>
<li>When <code>a</code> is <code>Nothing</code>, <code>b</code> is <code>Nothing</code>, then <code>c</code> is <code>Nothing</code>.</li>
<li><code>empty</code> is synonymous to <code>Nothing</code> here.</li>
</ul>
</section>
<section id="evaluate-the-alternative" class="level2">
<h2>Evaluate the alternative</h2>
<pre class="sourceCode haskell"><code class="sourceCode haskell">example2 <span class="fu">=</span> <span class="dt">Nothing</span> <span class="fu"><|></span> <span class="dt">Nothing</span> <span class="fu"><|></span> <span class="dt">Just</span> <span class="dv">3</span> <span class="fu"><|></span> <span class="dt">Just</span> <span class="dv">4</span>
example2 <span class="fu">=</span> <span class="dt">Nothing</span> <span class="fu"><|></span> <span class="dt">Just</span> <span class="dv">3</span> <span class="fu"><|></span> <span class="dt">Just</span> <span class="dv">4</span>
example2 <span class="fu">=</span> <span class="dt">Just</span> <span class="dv">3</span> <span class="fu"><|></span> <span class="dt">Just</span> <span class="dv">4</span>
example2 <span class="fu">=</span> <span class="dt">Just</span> <span class="dv">3</span></code></pre>
</section>
</section>
<section id="where-this-leads" class="level1">
<h1>Where this leads</h1>
<p>So, after all these wonderful concepts have been discussed, where are we heading with this?</p>
<p>We can use Currying, Applicatives, and Alternatives to parse JSON documents and get the first <em>reasonable</em> value.</p>
</section>
<section id="aeson" class="level1">
<h1>Aeson</h1>
<section id="it-is-a-library" class="level2">
<h2>It is a library</h2>
<p>Aeson lets us encode and decode our data types with JSON.</p>
<pre class="sourceCode haskell"><code class="sourceCode haskell"><span class="kw">data</span> <span class="dt">Person</span> <span class="fu">=</span> <span class="dt">Person</span>
{<span class="ot"> name ::</span> <span class="dt">Text</span>
,<span class="ot"> age ::</span> <span class="dt">Int</span>
} <span class="kw">deriving</span> <span class="dt">Show</span>
<span class="kw">instance</span> <span class="dt">FromJSON</span> <span class="dt">Person</span> <span class="kw">where</span>
parseJSON (<span class="dt">Object</span> v) <span class="fu">=</span> <span class="dt">Person</span> <span class="fu"><$></span> v <span class="fu">.:</span> <span class="st">"name"</span> <span class="fu"><*></span> v <span class="fu">.:</span> <span class="st">"age"</span>
<span class="co">-- A non-Object value is of the wrong type, so fail.</span>
parseJSON _ <span class="fu">=</span> mzero
<span class="kw">instance</span> <span class="dt">ToJSON</span> <span class="dt">Person</span> <span class="kw">where</span>
toJSON (<span class="dt">Person</span> name age) <span class="fu">=</span> object [<span class="st">"name"</span> <span class="fu">.=</span> name, <span class="st">"age"</span> <span class="fu">.=</span> age]
<span class="co">-- (.:) and (.=) are custom aeson infix operators</span>
<span class="fu">>>></span> decode <span class="st">"{\"name\":\"Joe\",\"age\":12}"</span><span class="ot"> ::</span> <span class="dt">Maybe</span> <span class="dt">Person</span>
<span class="dt">Just</span> (<span class="dt">Person</span> {name <span class="fu">=</span> <span class="st">"Joe"</span>, age <span class="fu">=</span> <span class="dv">12</span>})</code></pre>
<p>See the Currying and Applicative being used?</p>
</section>
<section id="curry-and-applicative" class="level2">
<h2>Curry and Applicative</h2>
<pre class="sourceCode haskell"><code class="sourceCode haskell"><span class="kw">data</span> <span class="dt">Person</span> <span class="fu">=</span> <span class="dt">Person</span> <span class="dt">Text</span> <span class="dt">Int</span>
<span class="kw">instance</span> <span class="dt">FromJSON</span> <span class="dt">Person</span> <span class="kw">where</span>
parseJSON (<span class="dt">Object</span> v) <span class="fu">=</span> <span class="dt">Person</span> <span class="fu"><$></span> v <span class="fu">.:</span> <span class="st">"name"</span> <span class="fu"><*></span> v <span class="fu">.:</span> <span class="st">"age"</span>
<span class="co">-- In this case, v .: "name" is :: Parser Text</span>
<span class="co">-- In this case, v .: "age" is :: Parser Int</span>
<span class="co">-- Parser is a member of the Applicative typeclass and</span>
<span class="co">-- acts much like Maybe</span>
<span class="dt">Person</span><span class="ot"> ::</span> <span class="dt">Text</span> <span class="ot">-></span> <span class="dt">Int</span> <span class="ot">-></span> <span class="dt">Person</span>
<span class="dt">Person</span> <span class="st">"Joe"</span><span class="ot"> ::</span> <span class="dt">Int</span> <span class="ot">-></span> <span class="dt">Person</span>
<span class="dt">Person</span> <span class="st">"Joe"</span> <span class="dv">12</span><span class="ot"> ::</span> <span class="dt">Person</span></code></pre>
</section>
<section id="what-about-sum-types" class="level2">
<h2>What about sum types?</h2>
<pre class="sourceCode haskell"><code class="sourceCode haskell"><span class="kw">data</span> <span class="dt">Color</span> <span class="fu">=</span> <span class="dt">ARGB</span> <span class="dt">Int</span> <span class="dt">Int</span> <span class="dt">Int</span> <span class="dt">Int</span>
<span class="fu">|</span> <span class="dt">RGB</span> <span class="dt">Int</span> <span class="dt">Int</span> <span class="dt">Int</span>
<span class="fu">|</span> <span class="dt">HSV</span> <span class="dt">Float</span> <span class="dt">Float</span> <span class="dt">Float</span>
<span class="fu">|</span> <span class="dt">CMYK</span> <span class="dt">Float</span> <span class="dt">Float</span> <span class="dt">Float</span> <span class="dt">Float</span></code></pre>
<p>Some try to go for something like..</p>
<pre class="sourceCode json"><code class="sourceCode json"><span class="fu">{</span><span class="dt">"type"</span><span class="fu">:</span><span class="st">"argb"</span><span class="fu">,</span><span class="dt">"value"</span><span class="fu">:{</span><span class="dt">"alpha"</span><span class="fu">:</span><span class="dv">255</span><span class="fu">,</span><span class="dt">"red"</span><span class="fu">:</span><span class="dv">128</span><span class="fu">,</span><span class="dt">"green"</span><span class="fu">:</span><span class="dv">195</span><span class="fu">,</span><span class="dt">"blue"</span><span class="fu">:</span><span class="dv">237</span><span class="fu">}}</span>
<span class="fu">{</span><span class="dt">"type"</span><span class="fu">:</span><span class="st">"hsv"</span><span class="fu">,</span><span class="dt">"value"</span><span class="fu">:{</span><span class="dt">"hue"</span><span class="fu">:</span><span class="fl">203.12</span><span class="fu">,</span><span class="dt">"saturation"</span><span class="fu">:</span><span class="fl">75.17</span><span class="fu">,</span><span class="dt">"value"</span><span class="fu">:</span><span class="fl">71.57</span><span class="fu">}}</span></code></pre>
<p>But doesn't that seem a little clunky..?</p>
</section>
<section id="encoding-sum-types" class="level2">
<h2>Encoding sum types</h2>
<pre class="sourceCode haskell"><code class="sourceCode haskell"><span class="kw">data</span> <span class="dt">Color</span> <span class="fu">=</span> <span class="dt">ARGB</span> <span class="dt">Int</span> <span class="dt">Int</span> <span class="dt">Int</span> <span class="dt">Int</span> <span class="fu">|</span> <span class="dt">RGB</span> <span class="dt">Int</span> <span class="dt">Int</span> <span class="dt">Int</span>
<span class="fu">|</span> <span class="dt">HSV</span> <span class="dt">Float</span> <span class="dt">Float</span> <span class="dt">Float</span> <span class="fu">|</span> <span class="dt">CMYK</span> <span class="dt">Float</span> <span class="dt">Float</span> <span class="dt">Float</span> <span class="dt">Float</span>
<span class="kw">instance</span> <span class="dt">ToJSON</span> <span class="dt">Color</span> <span class="kw">where</span>
toJSON (<span class="dt">ARGB</span> a r g b) <span class="fu">=</span> object
[<span class="st">"alpha"</span> <span class="fu">.=</span> a, <span class="st">"red"</span> <span class="fu">.=</span> r, <span class="st">"green"</span> <span class="fu">.=</span> g, <span class="st">"blue"</span> <span class="fu">.=</span> b]
toJSON (<span class="dt">RGB</span> r g b) <span class="fu">=</span> object
[<span class="st">"red"</span> <span class="fu">.=</span> r, <span class="st">"green"</span> <span class="fu">.=</span> g, <span class="st">"blue"</span> <span class="fu">.=</span> b]
toJSON (<span class="dt">HSV</span> h s v) <span class="fu">=</span> object
[<span class="st">"hue"</span> <span class="fu">.=</span> h, <span class="st">"saturation"</span> <span class="fu">.=</span> s, <span class="st">"value"</span> <span class="fu">.=</span> v]
toJSON (<span class="dt">CYMK</span> c y m k) <span class="fu">=</span> object
[<span class="st">"cyan"</span> <span class="fu">.=</span> c, <span class="st">"yellow"</span> <span class="fu">.=</span> y, <span class="st">"magenta"</span> <span class="fu">.=</span> m, <span class="st">"key"</span> <span class="fu">.=</span> k]
encode <span class="fu">$</span> <span class="dt">ARGB</span> <span class="dv">255</span> <span class="dv">128</span> <span class="dv">195</span> <span class="dv">237</span>
<span class="fu">>>></span> <span class="st">"{\"red\":128,\"alpha\":255,\"green\":195,\"blue\":237}"</span>
encode <span class="fu">$</span> <span class="dt">HSV</span> <span class="fl">203.12</span> <span class="fl">75.17</span> <span class="fl">71.57</span>
<span class="fu">>>></span> <span class="st">"{\"hue\":203.12,\"saturation\":75.17,\"value\":71.57}"</span></code></pre>
<p>We can do this, but can we recover which constructor to use? (ARGB vs RGB)</p>
</section>
<section id="what-about-alternative" class="level2">
<h2>What about alternative?</h2>
<pre class="sourceCode haskell"><code class="sourceCode haskell"><span class="kw">instance</span> <span class="dt">FromJSON</span> <span class="dt">Color</span> <span class="kw">where</span>
parseJSON (<span class="dt">Object</span> v)
<span class="fu">=</span> <span class="dt">ARGB</span> <span class="fu"><$></span> v <span class="fu">.:</span> <span class="st">"alpha"</span>
<span class="fu"><*></span> v <span class="fu">.:</span> <span class="st">"red"</span>
<span class="fu"><*></span> v <span class="fu">.:</span> <span class="st">"green"</span>
<span class="fu"><*></span> v <span class="fu">.:</span> <span class="st">"blue"</span>
<span class="fu"><|></span> <span class="dt">RGB</span> <span class="fu"><$></span> v <span class="fu">.:</span> <span class="st">"red"</span>
<span class="fu"><*></span> v <span class="fu">.:</span> <span class="st">"green"</span>
<span class="fu"><*></span> v <span class="fu">.:</span> <span class="st">"blue"</span>
<span class="fu"><|></span> <span class="dt">HSV</span> <span class="fu"><$></span> v <span class="fu">.:</span> <span class="st">"hue"</span>
<span class="fu"><*></span> v <span class="fu">.:</span> <span class="st">"saturation"</span>
<span class="fu"><*></span> v <span class="fu">.:</span> <span class="st">"value"</span>
<span class="fu"><|></span> <span class="dt">CYMK</span> <span class="fu"><$></span> v <span class="fu">.:</span> <span class="st">"cyan"</span>
<span class="fu"><*></span> v <span class="fu">.:</span> <span class="st">"yellow"</span>
<span class="fu"><*></span> v <span class="fu">.:</span> <span class="st">"magenta"</span>
<span class="fu"><*></span> v <span class="fu">.:</span> <span class="st">"key"</span></code></pre>
</section>
<section id="demo-of-alternative" class="level2">
<h2>Demo of alternative</h2>
<pre class="sourceCode haskell"><code class="sourceCode haskell"><span class="fu">>>></span> <span class="kw">let</span> json <span class="fu">=</span> <span class="st">"{\"red\":128,\"alpha\":255,\"green\":195,\"blue\":237}"</span>
<span class="fu">>>></span> decode<span class="ot"> json ::</span> <span class="dt">Maybe</span> <span class="dt">Color</span>
<span class="dt">Just</span> (<span class="dt">ARGB</span> <span class="dv">255</span> <span class="dv">128</span> <span class="dv">195</span> <span class="dv">237</span>)</code></pre>
<p>Well look at that, we could recover the constructor! (ARGB)</p>
<p>Though we do have a little redundancy with our implementation..</p>
</section>
<section id="slight-cleanup" class="level2">
<h2>Slight cleanup</h2>
<pre class="sourceCode haskell"><code class="sourceCode haskell"><span class="kw">instance</span> <span class="dt">FromJSON</span> <span class="dt">Color</span> <span class="kw">where</span>
parseJSON (<span class="dt">Object</span> v)
<span class="fu">=</span> empty
<span class="fu"><|></span> <span class="kw">do</span> r <span class="ot"><-</span> v <span class="fu">.:</span> <span class="st">"red"</span>
g <span class="ot"><-</span> v <span class="fu">.:</span> <span class="st">"green"</span>
b <span class="ot"><-</span> v <span class="fu">.:</span> <span class="st">"blue"</span>
<span class="kw">let</span> argb a <span class="fu">=</span> <span class="dt">ARGB</span> a r g b
(argb <span class="fu"><$></span> v <span class="fu">.:</span> <span class="st">"alpha"</span>) <span class="fu"><|></span> (pure <span class="fu">$</span> <span class="dt">RGB</span> r g b)
<span class="fu"><|></span> <span class="dt">HSV</span> <span class="fu"><$></span> v <span class="fu">.:</span> <span class="st">"hue"</span>
<span class="fu"><*></span> v <span class="fu">.:</span> <span class="st">"saturation"</span>
<span class="fu"><*></span> v <span class="fu">.:</span> <span class="st">"value"</span>
<span class="fu"><|></span> <span class="dt">CYMK</span> <span class="fu"><$></span> v <span class="fu">.:</span> <span class="st">"cyan"</span>
<span class="fu"><*></span> v <span class="fu">.:</span> <span class="st">"yellow"</span>
<span class="fu"><*></span> v <span class="fu">.:</span> <span class="st">"magenta"</span>
<span class="fu"><*></span> v <span class="fu">.:</span> <span class="st">"key"</span></code></pre>
<p>This shares the <code>"red"</code>, <code>"green"</code>, and <code>"blue"</code> among both <code>RGB</code> and <code>ARGB</code> constructors for <code>Color</code>.</p>
</section>
</section>
<section id="finale" class="level1">
<h1>Finale</h1>
<p>Let your Haskelling be practical.</p>
<p>And with respect, live long and prosper.</p>
<figure>
<img src="images/spock.jpg" />
</figure>
</section>
</div>
<script src="reveal.js/lib/js/head.min.js"></script>
<script src="reveal.js/js/reveal.js"></script>
<script>
// Full list of configuration options available here:
// https://github.com/hakimel/reveal.js#configuration
Reveal.initialize({
controls: true,
progress: true,
history: true,
center: false,
// available themes are in /css/theme
theme: Reveal.getQueryHash().theme || 'black',
// default/cube/page/concave/zoom/linear/fade/none
transition: Reveal.getQueryHash().transition || 'default',
// Optional libraries used to extend on reveal.js
dependencies: [
{ src: 'reveal.js/lib/js/classList.js', condition: function() { return !document.body.classList; } },
{ src: 'reveal.js/plugin/markdown/showdown.js', condition: function() { return !!document.querySelector( '[data-markdown]' ); } },
{ src: 'reveal.js/plugin/markdown/markdown.js', condition: function() { return !!document.querySelector( '[data-markdown]' ); } },
{ src: 'highlight/highlight.pack.js', async: true, callback: function() { hljs.initHighlightingOnLoad(); } },
{ src: 'reveal.js/plugin/zoom-js/zoom.js', async: true, condition: function() { return !!document.body.classList; } },
{ src: 'reveal.js/plugin/notes/notes.js', async: true, condition: function() { return !!document.body.classList; } }
// { src: 'reveal.js/plugin/remotes/remotes.js', async: true, condition: function() { return !!document.body.classList; } }
]
});
</script>
</body>
</html>