-
Notifications
You must be signed in to change notification settings - Fork 1
/
canbuildfrom.html
392 lines (323 loc) · 32.3 KB
/
canbuildfrom.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
<!DOCTYPE html>
<html lang="en" prefix="og: http://ogp.me/ns# fb: https://www.facebook.com/2008/fbml">
<head>
<title>CanBuildFrom - Stackdiver as a Service</title>
<!-- Using the latest rendering mode for IE -->
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<link rel="canonical" href="https://www.lyh.me/canbuildfrom.html">
<meta name="author" content="Neville Li" />
<meta name="keywords" content="scala,fp" />
<meta name="description" content="We recently had an internal knowledge sharing on higher-kinded types and CanBuildFrom type classes in Scala. Here’s a short summary. Basics Let’s start by implementing map. def map(xs: Seq[Int], f: Int => Double): Seq[Double] = xs.map(f) map(Seq(1, 2, 3), _ + 0.1) This implementation is not very good since it only works with Seq[Int] and Int => Double. It’s easy to parameterize Int and Double. def map[A, B](xs: Seq[A], f: A => B): Seq[B] = xs.map(f) However map(Seq(1, 2, 3), _ + 0.1) now fails to compile with a message missing parameter type for expanded function ((x$1) => x$1.$plus(10)) This is because inference of A in f: A => B depends on the type of xs: Seq[A], and limitation of Scala type inference. A common workaround is to curry arguments. def map[A, B](xs: Seq[A])(f: A => B): Seq[B] = xs.map(f) map(Seq(1, 2, 3))(_ + 0.1) Similar pattern is commonly seen in Scala, like foldLeft(z: B)(op: (B, A) => B). Another benefit is we can now write f in a multi-line {} block more elegantly. map …" />
<meta property="og:site_name" content="Stackdiver as a Service" />
<meta property="og:type" content="article"/>
<meta property="og:title" content="CanBuildFrom"/>
<meta property="og:url" content="https://www.lyh.me/canbuildfrom.html"/>
<meta property="og:description" content="We recently had an internal knowledge sharing on higher-kinded types and CanBuildFrom type classes in Scala. Here’s a short summary. Basics Let’s start by implementing map. def map(xs: Seq[Int], f: Int => Double): Seq[Double] = xs.map(f) map(Seq(1, 2, 3), _ + 0.1) This implementation is not very good since it only works with Seq[Int] and Int => Double. It’s easy to parameterize Int and Double. def map[A, B](xs: Seq[A], f: A => B): Seq[B] = xs.map(f) However map(Seq(1, 2, 3), _ + 0.1) now fails to compile with a message missing parameter type for expanded function ((x$1) => x$1.$plus(10)) This is because inference of A in f: A => B depends on the type of xs: Seq[A], and limitation of Scala type inference. A common workaround is to curry arguments. def map[A, B](xs: Seq[A])(f: A => B): Seq[B] = xs.map(f) map(Seq(1, 2, 3))(_ + 0.1) Similar pattern is commonly seen in Scala, like foldLeft(z: B)(op: (B, A) => B). Another benefit is we can now write f in a multi-line {} block more elegantly. map …"/>
<meta property="article:published_time" content="2017-05-18" />
<meta property="article:section" content="code" />
<meta property="article:tag" content="scala" />
<meta property="article:tag" content="fp" />
<meta property="article:author" content="Neville Li" />
<!-- Bootstrap -->
<link rel="stylesheet" href="https://www.lyh.me/theme/css/bootstrap.min.css" type="text/css"/>
<link href="https://www.lyh.me/theme/css/font-awesome.min.css" rel="stylesheet">
<link href="https://www.lyh.me/theme/css/pygments/monokai.css" rel="stylesheet">
<link href="https://www.lyh.me/theme/css/typogrify.css" rel="stylesheet">
<link rel="stylesheet" href="https://www.lyh.me/theme/css/style.css" type="text/css"/>
<link href="https://www.lyh.me/feeds/all.atom.xml" type="application/atom+xml" rel="alternate"
title="Stackdiver as a Service ATOM Feed"/>
<link href="https://www.lyh.me/feeds/code.atom.xml" type="application/atom+xml" rel="alternate"
title="Stackdiver as a Service code ATOM Feed"/>
</head>
<body>
<div class="navbar navbar-default navbar-fixed-top" role="navigation">
<div class="container">
<div class="navbar-header">
<button type="button" class="navbar-toggle" data-toggle="collapse" data-target=".navbar-ex1-collapse">
<span class="sr-only">Toggle navigation</span>
<span class="icon-bar"></span>
<span class="icon-bar"></span>
<span class="icon-bar"></span>
</button>
<a href="https://www.lyh.me/" class="navbar-brand">
Stackdiver as a Service </a>
</div>
<div class="collapse navbar-collapse navbar-ex1-collapse">
<ul class="nav navbar-nav">
<li><a href="https://www.lyh.me/pages/about-me.html">
About Me
</a></li>
</ul>
<ul class="nav navbar-nav navbar-right">
</ul>
</div>
<!-- /.navbar-collapse -->
</div>
</div> <!-- /.navbar -->
<!-- Banner -->
<!-- End Banner -->
<!-- Content Container -->
<div class="container">
<div class="row">
<div class="col-sm-9">
<section id="content">
<article>
<header class="page-header">
<h1>
<a href="https://www.lyh.me/canbuildfrom.html"
rel="bookmark"
title="Permalink to CanBuildFrom">
CanBuildFrom
</a>
</h1>
</header>
<div class="entry-content">
<div class="panel">
<div class="panel-body">
<footer class="post-info">
<span class="label label-default">Date</span>
<span class="published">
<i class="fa fa-calendar"></i><time datetime="2017-05-18T09:46:00-04:00"> Thu 18 May 2017</time>
</span>
<span class="label label-default">Category</span>
<a href="https://www.lyh.me/category/code.html">code</a>
<span class="label label-default">Tags</span>
<a href="https://www.lyh.me/tag/scala.html">scala</a>
/
<a href="https://www.lyh.me/tag/fp.html">fp</a>
</footer><!-- /.post-info --> </div>
</div>
<p>We recently had an internal knowledge sharing on higher-kinded types and <code>CanBuildFrom</code> type classes in Scala. Here’s a short summary.</p>
<h2>Basics</h2>
<p>Let’s start by implementing <code>map</code>.</p>
<div class="highlight"><pre><span></span><code><span class="k">def</span> <span class="n">map</span><span class="o">(</span><span class="n">xs</span><span class="k">:</span> <span class="kt">Seq</span><span class="o">[</span><span class="kt">Int</span><span class="o">],</span> <span class="n">f</span><span class="k">:</span> <span class="kt">Int</span> <span class="o">=></span> <span class="nc">Double</span><span class="o">)</span><span class="k">:</span> <span class="kt">Seq</span><span class="o">[</span><span class="kt">Double</span><span class="o">]</span> <span class="k">=</span> <span class="n">xs</span><span class="o">.</span><span class="n">map</span><span class="o">(</span><span class="n">f</span><span class="o">)</span>
<span class="n">map</span><span class="o">(</span><span class="nc">Seq</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="k">_</span> <span class="o">+</span> <span class="mf">0.1</span><span class="o">)</span>
</code></pre></div>
<p>This implementation is not very good since it only works with <code>Seq[Int]</code> and <code>Int => Double</code>. It’s easy to parameterize <code>Int</code> and <code>Double</code>.</p>
<div class="highlight"><pre><span></span><code><span class="k">def</span> <span class="n">map</span><span class="o">[</span><span class="kt">A</span><span class="p">,</span> <span class="kt">B</span><span class="o">](</span><span class="n">xs</span><span class="k">:</span> <span class="kt">Seq</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">=></span> <span class="n">B</span><span class="o">)</span><span class="k">:</span> <span class="kt">Seq</span><span class="o">[</span><span class="kt">B</span><span class="o">]</span> <span class="k">=</span> <span class="n">xs</span><span class="o">.</span><span class="n">map</span><span class="o">(</span><span class="n">f</span><span class="o">)</span>
</code></pre></div>
<p>However <code>map(Seq(1, 2, 3), _ + 0.1)</code> now fails to compile with a message <code>missing parameter type for expanded function ((x$1) => x$1.$plus(10))</code></p>
<p>This is because inference of <code>A</code> in <code>f: A => B</code> depends on the type of <code>xs: Seq[A]</code>, and limitation of Scala type inference. A common workaround is to curry arguments.</p>
<div class="highlight"><pre><span></span><code><span class="k">def</span> <span class="n">map</span><span class="o">[</span><span class="kt">A</span><span class="p">,</span> <span class="kt">B</span><span class="o">](</span><span class="n">xs</span><span class="k">:</span> <span class="kt">Seq</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">=></span> <span class="n">B</span><span class="o">)</span><span class="k">:</span> <span class="kt">Seq</span><span class="o">[</span><span class="kt">B</span><span class="o">]</span> <span class="k">=</span> <span class="n">xs</span><span class="o">.</span><span class="n">map</span><span class="o">(</span><span class="n">f</span><span class="o">)</span>
<span class="n">map</span><span class="o">(</span><span class="nc">Seq</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="k">_</span> <span class="o">+</span> <span class="mf">0.1</span><span class="o">)</span>
</code></pre></div>
<p>Similar pattern is commonly seen in Scala, like <code>foldLeft(z: B)(op: (B, A) => B)</code>. Another benefit is we can now write <code>f</code> in a multi-line <code>{}</code> block more elegantly.</p>
<div class="highlight"><pre><span></span><code><span class="n">map</span><span class="o">(</span><span class="nc">Seq</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="n">x</span> <span class="k">=></span>
<span class="k">val</span> <span class="n">y</span> <span class="k">=</span> <span class="n">x</span> <span class="o">+</span> <span class="mf">0.1</span>
<span class="n">println</span><span class="o">(</span><span class="s">s"</span><span class="si">$x</span><span class="s"> + 0.5 = </span><span class="si">$y</span><span class="s">"</span><span class="o">)</span>
<span class="n">y</span>
<span class="o">}</span>
</code></pre></div>
<h2>Higher-kinded types</h2>
<p>However this version still only works on <code>Seq[A]</code>. We could parameterize it as <code>M[_]</code>, also known as higher-kinded type.</p>
<div class="highlight"><pre><span></span><code><span class="k">import</span> <span class="nn">scala.language.higherKinds</span>
<span class="k">def</span> <span class="n">map</span><span class="o">[</span><span class="kt">M</span><span class="o">[</span><span class="k">_</span><span class="o">]</span><span class="p">,</span> <span class="kt">A</span><span class="p">,</span> <span class="kt">B</span><span class="o">](</span><span class="n">xs</span><span class="k">:</span> <span class="kt">M</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">=></span> <span class="n">B</span><span class="o">)</span><span class="k">:</span> <span class="kt">M</span><span class="o">[</span><span class="kt">B</span><span class="o">]</span> <span class="k">=</span> <span class="n">xs</span><span class="o">.</span><span class="n">map</span><span class="o">(</span><span class="n">f</span><span class="o">)</span>
</code></pre></div>
<p>But now we have a compiler error saying <code>value map is not a member of type parameter M[A]</code>. We can add a upper bound for <code>M[_]</code> but it still wouldn’t work.</p>
<div class="highlight"><pre><span></span><code><span class="k">def</span> <span class="n">map</span><span class="o">[</span><span class="kt">M</span><span class="o">[</span><span class="k">_</span><span class="o">]</span> <span class="k"><:</span> <span class="kt">Seq</span><span class="o">[</span><span class="kt">A</span><span class="o">]</span><span class="p">,</span> <span class="kt">A</span><span class="p">,</span> <span class="kt">B</span><span class="o">](</span><span class="n">xs</span><span class="k">:</span> <span class="kt">M</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">=></span> <span class="n">B</span><span class="o">)</span><span class="k">:</span> <span class="kt">M</span><span class="o">[</span><span class="kt">B</span><span class="o">]</span> <span class="k">=</span> <span class="n">xs</span><span class="o">.</span><span class="n">map</span><span class="o">(</span><span class="n">f</span><span class="o">)</span>
</code></pre></div>
<p>Despite the fact that <code>M[_]</code> is a sub-type of <code>Seq[A]</code>, and <code>Seq[A]</code> has a <code>map</code> method, we can’t build a <code>M[B]</code> back from <code>Seq[A]#map[B](f: A => B)</code>, since <code>M[B]</code> is a more specific type than <code>Seq[B]</code>.</p>
<div class="highlight"><pre><span></span><code><span class="n">type</span><span class="w"> </span><span class="n">mismatch</span><span class="p">;</span><span class="w"></span>
<span class="o">[</span><span class="n">error</span><span class="o">]</span><span class="w"> </span><span class="k">found</span><span class="w"> </span><span class="err">:</span><span class="w"> </span><span class="n">Seq</span><span class="o">[</span><span class="n">B</span><span class="o">]</span><span class="w"></span>
<span class="o">[</span><span class="n">error</span><span class="o">]</span><span class="w"> </span><span class="nl">required</span><span class="p">:</span><span class="w"> </span><span class="n">M</span><span class="o">[</span><span class="n">B</span><span class="o">]</span><span class="w"></span>
</code></pre></div>
<p>However if we look at the method signature of <code>Seq[A]#map(f: A => B)</code> it actually looks like this.</p>
<div class="highlight"><pre><span></span><code><span class="k">trait</span> <span class="nc">TraversableLike</span><span class="o">[</span><span class="kt">+A</span><span class="p">,</span> <span class="kt">+Repr</span><span class="o">]</span> <span class="o">{</span>
<span class="k">def</span> <span class="n">map</span><span class="o">[</span><span class="kt">B</span><span class="p">,</span> <span class="kt">That</span><span class="o">](</span><span class="n">f</span><span class="k">:</span> <span class="kt">A</span> <span class="o">=></span> <span class="n">B</span><span class="o">)(</span><span class="k">implicit</span> <span class="n">bf</span><span class="k">:</span> <span class="kt">CanBuildFrom</span><span class="o">[</span><span class="kt">Repr</span><span class="p">,</span> <span class="kt">B</span><span class="p">,</span> <span class="kt">That</span><span class="o">])</span><span class="k">:</span> <span class="kt">That</span>
<span class="o">}</span>
</code></pre></div>
<p>Note that it’s a method on <code>trait TraversableLike</code>, which means any <code>TraversableLike</code> collection can share the same <code>map</code> implementation. Also worth noting is <code>Seq[+A]</code> has an inheritance hierarchy like this:</p>
<div class="highlight"><pre><span></span><code><span class="k">trait</span> <span class="nc">Seq</span><span class="o">[</span><span class="kt">+A</span><span class="o">]</span> <span class="k">extends</span> <span class="nc">SeqLike</span><span class="o">[</span><span class="kt">A</span><span class="p">,</span> <span class="kt">Seq</span><span class="o">[</span><span class="kt">A</span><span class="o">]]</span> <span class="c1">// ...</span>
<span class="k">trait</span> <span class="nc">SeqLike</span><span class="o">[</span><span class="kt">+A</span><span class="p">,</span> <span class="kt">+Repr</span><span class="o">]</span> <span class="k">extends</span> <span class="nc">IterableLike</span><span class="o">[</span><span class="kt">A</span><span class="p">,</span> <span class="kt">Repr</span><span class="o">]</span> <span class="c1">// ...</span>
<span class="k">trait</span> <span class="nc">IterableLike</span><span class="o">[</span><span class="kt">+A</span><span class="p">,</span> <span class="kt">+Repr</span><span class="o">]</span> <span class="k">extends</span> <span class="nc">TraversableLike</span><span class="o">[</span><span class="kt">A</span><span class="p">,</span> <span class="kt">Repr</span><span class="o">]</span> <span class="c1">// ...</span>
</code></pre></div>
<p>We see that in <code>Seq[A] extends SeqLike[A, Seq[A]]</code>, type of the current trait <code>Seq[A]</code> is also used as a type parameter for the super-type, which is propagated all the way to <code>TraversableLike</code>. This is commonly known as F-bounded polymorphism, which is useful heere since methods on sub-types of <code>TraversableLike</code> can now return a more specific type, e.g. <code>Seq</code>, <code>List</code>, <code>Vector</code>, instead of the same broad super-type. For more information on F-bounded polymorphism, check out Marconi Lanna’s <a href="https://github.com/marconilanna/NEScala2015">excellent presentation</a> at NEScala 2015.</p>
<p>In the case of <code>Seq[Int]#map(f: Int => Double)</code>, we can expand the method like this:</p>
<div class="highlight"><pre><span></span><code><span class="k">def</span> <span class="n">map</span><span class="o">[</span><span class="kt">Int</span><span class="p">,</span> <span class="kt">That</span><span class="o">](</span><span class="n">f</span><span class="k">:</span> <span class="kt">Int</span> <span class="o">=></span> <span class="nc">Double</span><span class="o">)(</span><span class="k">implicit</span> <span class="n">bf</span><span class="k">:</span> <span class="kt">CanBuildFrom</span><span class="o">[</span><span class="kt">Seq</span><span class="o">[</span><span class="kt">Int</span><span class="o">]</span><span class="p">,</span> <span class="kt">Double</span><span class="p">,</span> <span class="kt">That</span><span class="o">])</span>
</code></pre></div>
<h2>CanBuildFrom</h2>
<p><code>CanBuildFrom</code> is a key type class in the Scala collections library and enables a lot code reuse.</p>
<div class="highlight"><pre><span></span><code><span class="k">trait</span> <span class="nc">CanBuildFrom</span><span class="o">[</span><span class="kt">-From</span><span class="p">,</span> <span class="kt">-Elem</span><span class="p">,</span> <span class="kt">+To</span><span class="o">]</span>
</code></pre></div>
<p>In its type signature, <code>From</code> is the original collection and <code>To</code> is the target collection. <code>Elem</code> is the element type of the target collection and in some determines the type of <code>To</code>. For example we can map over a <code>Map[K, V]</code> into <code>K -> V</code> (which is a syntactic sugar for <code>(K, V)</code>), and get another map. However mapping into <code>String</code> would result in a <code>List[String]</code> since one cannot build a <code>Map[K, V]</code> with a single type.</p>
<div class="highlight"><pre><span></span><code><span class="c1">// From: Map[String, Int]</span>
<span class="c1">// (String, Int) => (String, Double)</span>
<span class="c1">// To: Map[String, Double]</span>
<span class="c1">// CanBuildFrom[Map[String, Int], (String, Double), Map[String, Double]]</span>
<span class="nc">Map</span><span class="o">(</span><span class="s">"a"</span> <span class="o">-></span> <span class="mi">1</span><span class="o">,</span> <span class="s">"b"</span> <span class="o">-></span> <span class="mi">2</span><span class="o">).</span><span class="n">map</span><span class="o">(</span><span class="n">kv</span> <span class="k">=></span> <span class="n">kv</span><span class="o">.</span><span class="n">_1</span> <span class="o">-></span> <span class="n">kv</span><span class="o">.</span><span class="n">_2</span> <span class="o">+</span> <span class="mf">0.1</span><span class="o">)</span>
<span class="c1">// From: Map[String, Int]</span>
<span class="c1">// (String, Int) => String</span>
<span class="c1">// To: List[String]</span>
<span class="c1">// CanBuildFrom[Map[String, Int], String, List[String]]</span>
<span class="nc">Map</span><span class="o">(</span><span class="s">"a"</span> <span class="o">-></span> <span class="mi">1</span><span class="o">,</span> <span class="s">"b"</span> <span class="o">-></span> <span class="mi">2</span><span class="o">).</span><span class="n">map</span><span class="o">(</span><span class="n">kv</span> <span class="k">=></span> <span class="n">kv</span><span class="o">.</span><span class="n">_1</span> <span class="o">+</span> <span class="n">kv</span><span class="o">.</span><span class="n">_2</span><span class="o">.</span><span class="n">toString</span><span class="o">)</span>
</code></pre></div>
<p>We can use <code>CanBuildFrom</code> to rewrite our <code>map</code> function.</p>
<div class="highlight"><pre><span></span><code><span class="k">def</span> <span class="n">map</span><span class="o">[</span><span class="kt">M</span><span class="o">[</span><span class="k">_</span><span class="o">]</span> <span class="k"><:</span> <span class="kt">Seq</span><span class="o">[</span><span class="kt">A</span><span class="o">]</span><span class="p">,</span> <span class="kt">A</span><span class="p">,</span> <span class="kt">B</span><span class="o">](</span><span class="n">xs</span><span class="k">:</span> <span class="kt">M</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">=></span> <span class="n">B</span><span class="o">)</span>
<span class="o">(</span><span class="k">implicit</span> <span class="n">cbf</span><span class="k">:</span> <span class="kt">CanBuildFrom</span><span class="o">[</span><span class="kt">M</span><span class="o">[</span><span class="kt">A</span><span class="o">]</span><span class="p">,</span> <span class="kt">B</span><span class="p">,</span> <span class="kt">M</span><span class="o">[</span><span class="kt">B</span><span class="o">]])</span><span class="k">:</span> <span class="kt">M</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">b</span> <span class="k">=</span> <span class="n">cbf</span><span class="o">()</span> <span class="c1">// new Builder[Elem, To]</span>
<span class="n">xs</span><span class="o">.</span><span class="n">foreach</span><span class="o">(</span><span class="n">x</span> <span class="k">=></span> <span class="n">b</span> <span class="o">+=</span> <span class="n">f</span><span class="o">(</span><span class="n">x</span><span class="o">))</span>
<span class="n">b</span><span class="o">.</span><span class="n">result</span><span class="o">()</span>
<span class="o">}</span>
</code></pre></div>
<p>Our function can now support any <code>Seq</code> types without losing the type information.</p>
</div>
<!-- /.entry-content -->
<hr />
<!-- AddThis Button BEGIN -->
<div class="addthis_toolbox addthis_default_style">
<a class="addthis_button_facebook_like" fb:like:layout="button_count"></a>
<a class="addthis_button_tweet"></a>
<a class="addthis_button_google_plusone" g:plusone:size="medium"></a>
</div>
<!-- AddThis Button END -->
<hr/>
<section class="comments" id="comments">
<h2>Comments</h2>
<div id="disqus_thread"></div>
<script type="text/javascript">
/* * * CONFIGURATION VARIABLES: EDIT BEFORE PASTING INTO YOUR WEBPAGE * * */
var disqus_shortname = 'lyh'; // required: replace example with your forum shortname
var disqus_config = function () {
this.language = "en";
this.page.identifier = '2017-05-18-canbuildfrom';
this.page.url = 'https://www.lyh.me/canbuildfrom.html';
};
/* * * DON'T EDIT BELOW THIS LINE * * */
(function () {
var dsq = document.createElement('script');
dsq.type = 'text/javascript';
dsq.async = true;
dsq.src = '//' + disqus_shortname + '.disqus.com/embed.js';
(document.getElementsByTagName('head')[0] || document.getElementsByTagName('body')[0]).appendChild(dsq);
})();
</script>
<noscript>Please enable JavaScript to view the <a href="http://disqus.com/?ref_noscript">comments powered by
Disqus.</a></noscript>
<a href="http://disqus.com" class="dsq-brlink">comments powered by <span class="logo-disqus">Disqus</span></a>
</section>
</article>
</section>
</div>
<div class="col-sm-3" id="sidebar">
<aside>
<div id="aboutme">
<p>
<img width="100%" class="img-thumbnail" src="https://www.lyh.me//avatar.jpg"/>
</p>
<p>
<strong>About Neville Li</strong><br/>
Data infrastructure @<a href="https://twitter.com/Spotify">Spotify</a>, ex-@<a href="https://twitter.com/Yahoo">Yahoo</a> search, creator of <a href="https://github.com/spotify/scio">Scio</a>, technical cave & wreck diver, lefty guitar player
</p>
</div><!-- Sidebar -->
<section class="well well-sm">
<ul class="list-group list-group-flush">
<!-- Sidebar/Social -->
<li class="list-group-item">
<h4><i class="fa fa-home fa-lg"></i><span class="icon-label">Social</span></h4>
<ul class="list-group" id="social">
<li class="list-group-item"><a href="https://open.spotify.com/user/sinisa_lyh"><i class="fa fa-spotify fa-lg"></i> Spotify</a></li>
<li class="list-group-item"><a href="https://github.com/nevillelyh"><i class="fa fa-github-square fa-lg"></i> GitHub</a></li>
<li class="list-group-item"><a href="https://twitter.com/sinisa_lyh"><i class="fa fa-twitter-square fa-lg"></i> Twitter</a></li>
<li class="list-group-item"><a href="https://www.slideshare.net/sinisalyh"><i class="fa fa-slideshare fa-lg"></i> SlideShare</a></li>
<li class="list-group-item"><a href="https://www.youtube.com/user/sinisalyh/videos"><i class="fa fa-youtube-square fa-lg"></i> YouTube</a></li>
<li class="list-group-item"><a href="https://www.instagram.com/sinisa/"><i class="fa fa-instagram fa-lg"></i> Instagram</a></li>
<li class="list-group-item"><a href="https://www.flickr.com/photos/sinisa_lyh"><i class="fa fa-flickr fa-lg"></i> Flickr</a></li>
</ul>
</li>
<!-- End Sidebar/Social -->
<!-- Sidebar/Recent Posts -->
<li class="list-group-item">
<h4><i class="fa fa-home fa-lg"></i><span class="icon-label">Recent Posts</span></h4>
<ul class="list-group" id="recentposts">
<li class="list-group-item"><a href="https://www.lyh.me/magnolify.html">Magnolify</a></li>
<li class="list-group-item"><a href="https://www.lyh.me/featran.html">Featran</a></li>
<li class="list-group-item"><a href="https://www.lyh.me/automatic-type-class-derivation-with-shapeless.html">Automatic type-class derivation with Shapeless</a></li>
<li class="list-group-item"><a href="https://www.lyh.me/lambda-serialization.html">Lambda serialization</a></li>
<li class="list-group-item"><a href="https://www.lyh.me/lawfulness-of-aggregatebykey.html">Lawfulness of aggregateByKey</a></li>
</ul>
</li>
<!-- End Sidebar/Recent Posts -->
<!-- Sidebar/Categories -->
<li class="list-group-item">
<h4><i class="fa fa-home fa-lg"></i><span class="icon-label">Categories</span></h4>
<ul class="list-group" id="categories">
<li class="list-group-item">
<a href="https://www.lyh.me/category/code.html"><i class="fa fa-folder-open fa-lg"></i>code</a>
</li>
<li class="list-group-item">
<a href="https://www.lyh.me/category/misc.html"><i class="fa fa-folder-open fa-lg"></i>misc</a>
</li>
</ul>
</li>
<!-- End Sidebar/Categories -->
<!-- Sidebar/Twitter Timeline -->
<li class="list-group-item">
<h4><i class="fa fa-twitter fa-lg"></i><span class="icon-label">Latest Tweets</span></h4>
<div id="twitter_timeline">
<a class="twitter-timeline" data-width="250" data-height="300" data-dnt="true" data-theme="light" href="https://twitter.com/sinisa_lyh">Tweets by sinisa_lyh</a> <script async src="//platform.twitter.com/widgets.js" charset="utf-8"></script>
</div>
</li>
<!-- End Sidebar/Twitter Timeline -->
</ul>
</section>
<!-- End Sidebar --> </aside>
</div>
</div>
</div>
<!-- End Content Container -->
<footer>
<div class="container">
<hr>
<div class="row">
<div class="col-xs-10">© 2020 Neville Li
· Powered by <a href="https://github.com/getpelican/pelican-themes/tree/master/pelican-bootstrap3" target="_blank">pelican-bootstrap3</a>,
<a href="http://docs.getpelican.com/" target="_blank">Pelican</a>,
<a href="http://getbootstrap.com" target="_blank">Bootstrap</a> <p><small> <a rel="license" href="https://creativecommons.org/licenses/by-nc/4.0/deed.en"><img alt="Creative Commons License" style="border-width:0" src="//i.creativecommons.org/l/by-nc/4.0/80x15.png" /></a>
Content
licensed under a <a rel="license" href="https://creativecommons.org/licenses/by-nc/4.0/deed.en">Creative Commons Attribution-NonCommercial 4.0 International License</a>, except where indicated otherwise.
</small></p>
</div>
<div class="col-xs-2"><p class="pull-right"><i class="fa fa-arrow-up"></i> <a href="#">Back to top</a></p></div>
</div>
</div>
</footer>
<script src="https://www.lyh.me/theme/js/jquery.min.js"></script>
<!-- Include all compiled plugins (below), or include individual files as needed -->
<script src="https://www.lyh.me/theme/js/bootstrap.min.js"></script>
<!-- Enable responsive features in IE8 with Respond.js (https://github.com/scottjehl/Respond) -->
<script src="https://www.lyh.me/theme/js/respond.min.js"></script>
<!-- Disqus -->
<script type="text/javascript">
/* * * CONFIGURATION VARIABLES: EDIT BEFORE PASTING INTO YOUR WEBPAGE * * */
var disqus_shortname = 'lyh'; // required: replace example with your forum shortname
/* * * DON'T EDIT BELOW THIS LINE * * */
(function () {
var s = document.createElement('script');
s.async = true;
s.type = 'text/javascript';
s.src = '//' + disqus_shortname + '.disqus.com/count.js';
(document.getElementsByTagName('HEAD')[0] || document.getElementsByTagName('BODY')[0]).appendChild(s);
}());
</script>
<!-- End Disqus Code -->
<!-- Google Analytics -->
<script type="text/javascript">
var _gaq = _gaq || [];
_gaq.push(['_setAccount', 'UA-6988688-5']);
_gaq.push(['_trackPageview']);
(function () {
var ga = document.createElement('script');
ga.type = 'text/javascript';
ga.async = true;
ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
var s = document.getElementsByTagName('script')[0];
s.parentNode.insertBefore(ga, s);
})();
</script>
<!-- End Google Analytics Code -->
<script type="text/javascript">var addthis_config = {"data_track_addressbar": true};</script>
<script type="text/javascript" src="//s7.addthis.com/js/300/addthis_widget.js#pubid=sinisalyh"></script>
</body>
</html>