@@ -1,887 +1,703 @@
1−<!doctype html>
1+<!DOCTYPE html>
22<html>
3−
43<head>
54 <meta charset="utf-8">
6− <meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no">
7−
8− <link rel="stylesheet" href="css/reset.css">
9− <link rel="stylesheet" href="css/reveal.css">
10− <link rel="stylesheet" href="css/theme/superblack.css">
11−
12− <!-- Theme used for syntax highlighting of code -->
13− <link rel="stylesheet" href="lib/css/monokai.css">
14−
5+ <meta name="generator" content="pandoc">
6+ <meta name="author" content="Ilya Kostyuchenko">
7+ <title>1</title>
8+ <meta name="apple-mobile-web-app-capable" content="yes">
9+ <meta name="apple-mobile-web-app-status-bar-style" content="black-translucent">
10+ <meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no, minimal-ui">
11+ <link rel="stylesheet" href="reveal.js/css/reset.css">
12+ <link rel="stylesheet" href="reveal.js/css/reveal.css">
13+ <style>
14+ code{white-space: pre-wrap;}
15+ span.smallcaps{font-variant: small-caps;}
16+ span.underline{text-decoration: underline;}
17+ div.column{display: inline-block; vertical-align: top; width: 50%;}
18+ div.hanging-indent{margin-left: 1.5em; text-indent: -1.5em;}
19+ ul.task-list{list-style: none;}
20+ pre > code.sourceCode { white-space: pre; position: relative; }
21+ pre > code.sourceCode > span { display: inline-block; line-height: 1.25; }
22+ pre > code.sourceCode > span:empty { height: 1.2em; }
23+ code.sourceCode > span { color: inherit; text-decoration: inherit; }
24+ div.sourceCode { margin: 1em 0; }
25+ pre.sourceCode { margin: 0; }
26+ @media screen {
27+ div.sourceCode { overflow: auto; }
28+ }
29+ @media print {
30+ pre > code.sourceCode { white-space: pre-wrap; }
31+ pre > code.sourceCode > span { text-indent: -5em; padding-left: 5em; }
32+ }
33+ pre.numberSource code
34+ { counter-reset: source-line 0; }
35+ pre.numberSource code > span
36+ { position: relative; left: -4em; counter-increment: source-line; }
37+ pre.numberSource code > span > a:first-child::before
38+ { content: counter(source-line);
39+ position: relative; left: -1em; text-align: right; vertical-align: baseline;
40+ border: none; display: inline-block;
41+ -webkit-touch-callout: none; -webkit-user-select: none;
42+ -khtml-user-select: none; -moz-user-select: none;
43+ -ms-user-select: none; user-select: none;
44+ padding: 0 4px; width: 4em;
45+ background-color: #232629;
46+ color: #7a7c7d;
47+ }
48+ pre.numberSource { margin-left: 3em; border-left: 1px solid #7a7c7d; padding-left: 4px; }
49+ div.sourceCode
50+ { color: #cfcfc2; background-color: #232629; }
51+ @media screen {
52+ pre > code.sourceCode > span > a:first-child::before { text-decoration: underline; }
53+ }
54+ code span. { color: #cfcfc2; } /* Normal */
55+ code span.al { color: #95da4c; background-color: #4d1f24; font-weight: bold; } /* Alert */
56+ code span.an { color: #3f8058; } /* Annotation */
57+ code span.at { color: #2980b9; } /* Attribute */
58+ code span.bn { color: #f67400; } /* BaseN */
59+ code span.bu { color: #7f8c8d; } /* BuiltIn */
60+ code span.cf { color: #fdbc4b; font-weight: bold; } /* ControlFlow */
61+ code span.ch { color: #3daee9; } /* Char */
62+ code span.cn { color: #27aeae; font-weight: bold; } /* Constant */
63+ code span.co { color: #7a7c7d; } /* Comment */
64+ code span.cv { color: #7f8c8d; } /* CommentVar */
65+ code span.do { color: #a43340; } /* Documentation */
66+ code span.dt { color: #2980b9; } /* DataType */
67+ code span.dv { color: #f67400; } /* DecVal */
68+ code span.er { color: #da4453; text-decoration: underline; } /* Error */
69+ code span.ex { color: #0099ff; font-weight: bold; } /* Extension */
70+ code span.fl { color: #f67400; } /* Float */
71+ code span.fu { color: #8e44ad; } /* Function */
72+ code span.im { color: #27ae60; } /* Import */
73+ code span.in { color: #c45b00; } /* Information */
74+ code span.kw { color: #cfcfc2; font-weight: bold; } /* Keyword */
75+ code span.op { color: #cfcfc2; } /* Operator */
76+ code span.ot { color: #27ae60; } /* Other */
77+ code span.pp { color: #27ae60; } /* Preprocessor */
78+ code span.re { color: #2980b9; background-color: #153042; } /* RegionMarker */
79+ code span.sc { color: #3daee9; } /* SpecialChar */
80+ code span.ss { color: #da4453; } /* SpecialString */
81+ code span.st { color: #f44f4f; } /* String */
82+ code span.va { color: #27aeae; } /* Variable */
83+ code span.vs { color: #da4453; } /* VerbatimString */
84+ code span.wa { color: #da4453; } /* Warning */
85+ </style>
86+ <link rel="stylesheet" href="reveal.js/css/theme/superblack.css" id="theme">
1587 <!-- Printing and PDF exports -->
1688 <script>
17− var link = document.createElement('link');
89+ var link = document.createElement( 'link' );
1890 link.rel = 'stylesheet';
1991 link.type = 'text/css';
20− link.href = window.location.search.match(/print-pdf/gi) ? 'css/print/pdf.css' : 'css/print/paper.css';
21− document.getElementsByTagName('head')[0].appendChild(link);
92+ link.href = window.location.search.match( /print-pdf/gi ) ? 'reveal.js/css/print/pdf.css' : 'reveal.js/css/print/paper.css';
93+ document.getElementsByTagName( 'head' )[0].appendChild( link );
2294 </script>
95+ <!--[if lt IE 9]>
96+ <script src="reveal.js/lib/js/html5shiv.js"></script>
97+ <![endif]-->
98+ <style>
99+ div.sourceCode {
100+ background-color: transparent;
101+ overflow: auto;
102+ margin: 0em;
103+ }
104+
105+ pre.sourceCode {
106+ margin: 8px auto;
107+ }
108+ </style>
23109</head>
24−
25110<body>
26111 <div class="reveal">
27112 <div class="slides">
28− <section>
29− <h2>Функциональное программирование</h2>
30− <aside class="notes" data-markdown>
31− Функциональное программирование это не про использование map filter reduce.
32−
33− Функциональное программирование это вообще ортогонально к ооп.
34−
35− ИМХО проблема с ООП -- наследование (которое тоже ортогонально к ООП) -- нет разграничения между абстракцией и
36− реализацией.
37−
38− и вообще обзывание это функциональным программированием -- не совсем правильно.
39−
40− то, что мы сейчас будем пытаться сделать -- сделать код более переиспользуемым.
41−
42− сделать наши данные максимально тупыми => переиспользуемыми.
43−
44− пытаться комбинировать слишком умные куски -- не получится -- слишком сложно.
45−
46− мы хотим сделать простые куски, которые просто комбинировать и еще чтобы компилятор проверял эти наши
47− комбинации на валидность.
48− </aside>
49− </section>
50− <section data-markdown>
51− Функциональное программирование:
52− > функции -- это тоже данные.
53−
54− `Int -> Bool` (функция) -- ровно такие же данные как и `Int`. Их также можно складывать в структуры,
55− передавать как аргументы и т. п.
56− </section>
57−
58− <section>
59− <section>
60− <h1>нотация</h1>
61− </section>
62− <section>
63− <table width="100%">
64− <tr>
65− <td>
66− <pre>
67− <code class="java">int x;</code>
68− </pre>
69− </td>
70− <td>
71− <pre>
72− <code class="haskell">x :: Int</code>
73− </pre>
74− </td>
75− </tr>
76− <tr class="fragment">
77− <td>
78− <pre>
79− <code class="java">int f(int x)</code>
80− </pre>
81− </td>
82− <td>
83− <pre>
84− <code class="haskell">f :: Int -> Int</code>
85− </pre>
86− </td>
87− </tr>
88− <tr class="fragment">
89− <td>
90− <pre>
91− <code class="java">static <T> T f(T x)</code>
92− </pre>
93−
94− </td>
95− <td>
96− <pre>
97− <code class="haskell">f :: a -> a</code>
98− </pre>
99− </td>
100− </tr>
101− </table>
102− </section>
103− <section>
104− <table width="100%">
105− <tr>
106− <td>
107− <pre>
108− <code class="java">static <T> T f(T x)</code>
109− </pre>
110− </td>
111− <td>
112− <pre>
113− <code class="haskell">f :: a -> a</code>
114− </pre>
115− </td>
116− </tr>
117− <tr>
118− <td class="fragment">
119− <pre>
120− <code class="java">f(x);</code>
121− </pre>
122− </td>
123− <td class="fragment">
124− <pre>
125− <code class="haskell">f x</code>
126− </pre>
127− </td>
128− </tr>
129− <tr class="fragment">
130− <td>
131− <pre>
132− <code class="java">f(x, y);</code>
133− </pre>
134− </td>
135− <td>
136− <pre>
137− <code class="haskell">f x y</code>
138− </pre>
139− <pre class="fragment">
140− <code class="haskell">f x y = (f x) y</code>
141− </pre>
142− <aside class="notes">
143− Left-associative
144− Currying
145− </aside>
146− </td>
147− </td>
148− </tr>
149− </table>
150− </section>
151− <section>
152− <table width="100%">
153− <tr>
154− <td>
155− <pre>
156− <code class="java">static <T> T f(T x)
157−static <T> T g(T x)</code>
158− </pre>
159− </td>
160− <td>
161− <pre>
162− <code class="haskell">f :: a -> a
163−g :: a -> a</code>
164− </pre>
165− </td>
166− </tr>
167− <tr class="fragment">
168− <td>
169− <pre>
170− <code class="java">f(g(x));
171−g(f(x));</code>
172− </pre>
173− </td>
174− <td class="fragment">
175− <pre>
176− <code class="haskell">f (g x)
177−g (f x)</code>
178− </pre>
179− </td>
180− </tr>
181− </table>
182− </section>
183− </section>
184− <section>
185− <section>
186− <h1>
187− Композиция
188− </h1>
189− </section>
190− <section>
191− <pre><code class="haskell">f :: a -> a
192−g :: a -> a</code></pre>
193− <pre class="fragment"><code class="haskell">f (g x)</code></pre>
194− <pre class="fragment"><code class="haskell">(f . g) x == f (g x)</code></pre>
195− <pre class="fragment"><code class="haskell">h = f . g
196−h x == f (g x)</code></pre>
197− </section>
198− <section>
199− <pre><code class="haskell">f :: a -> a
200−g :: a -> a
201−
202−h :: a -> a
203−h = f . g</code></pre>
204−
205− <h3 class="fragment">моноид</h3>
206−
207− <aside class="notes" data-markdown>
208− моноид -- у тебя есть две штуки одного типа и ты можешь получить еще одну
209− штуку такого же
210− типа.
211−
212− Это очень простой способ рождения сложности из простоты
213−
214− причем тип h выводится из определения. Нам его указывать не надо.
215−
216− если у нас изначальные маленькие кусочки хорошо описаны, то порожденные большие кусочки будут автоматически
217− хорошо описанными.
218− </aside>
219− </section>
220− <section>
221− <h3>
222− Моноид
223− </h3>
224−
225− <p class="fragment">
226− Бинарная асоциативная операция
227− </p>
228−
229− <pre><code class="haskell fragment">(.) :: (a -> a) -> (a -> a) -> (a -> a)</code></pre>
230−
231− <p class="fragment">
232− Нейтральный элемент
233− </p>
234−
235− <pre><code class="haskell fragment">id :: a -> a
236−id x = x</code></pre>
237− </section>
238− </section>
239− </section>
240− <section>
241− <section>
242− <h2>Haskell</h2>
243− </section>
244− <section>
245− <h3>Чисто функционаьлный</h3>
246− <p class="fragment" data-markdown>Все что функция может сделать -- посмотреть на свои аргументы это вернуть
247− значение.</p>
248− <aside class="notes" data-markdown>Нельзя просто произвольно распечатать строку в консоль, нельзя просто
249− произвольно
250− отправить запрос на бд, нельзя просто произвольно изменить глобальную переменную.</aside>
251− </section>
252− <section>
253− <h3>Referential transparency</h3>
254− <h5>(Любую константу можно заменить на само значение)</h5>
255− <pre><code class="java fragment">int x = 8;
256−int y = x++;
257−System.out.println(y + " might be the same as " + y);</code></pre>
258− <pre><code class="java fragment">int x = 8;
259−System.out.println(x++ + " might be the same as " + x++);</code></pre>
260−
261− <aside class="notes" data-markdown>Сильно упрощает рефакторинг и понимание кода.</aside>
262− </section>
263− <section>
264− <h3>Нет переменных, циклов и условных переходов</h3>
265−
266− <p class="fragment" data-markdown>
267− Зато есть константы и нормальная рекурсия
268−
269− (А переходов вообще нет)
270− </p>
271− </section>
272− <section>
273− <h3>Очень ленивый</h3>
274−
275− <pre><code class="haskell fragment">xs = [4, 1, 3, 2]
276−xs' = sort xs
277−print xs</code></pre>
278−
279− <p class="fragment" data-markdown>
280− `xs'` не нужен чтобы распечатать `xs`, поэтому сортироваться ничто не будет.
281−
282− (Зачем делать то, что можно не делать)
283− </p>
284− </section>
285− <section>
286− <p>Если хотите быстро и просто потыкаться, тут есть интерктивная штука:</p>
287− <a href="https://www.haskell.org">haskell.org</a>
288− </section>
289− </section>
290− <section>
291− <h2>Синтаксис</h2>
292− </section>
293− <section>
294− <section>
295− <h2>Функции</h2>
296− </section>
297− <section>
298− <pre><code class="haskell">add2 :: Int -> Int
299−add2 x = x + 2</code></pre>
300− <p>Все функции и константы всегда обозначаются словами с маленькой буквы без пробелов.</p>
301− <p>(Константы это просто функции с нулем аргументов.)</p>
302− </section>
303− <section>
304− <h3>Pattern mathcing</h3>
305− <pre><code class="haskell">fixBuz :: Int -> String
306−divide8 3 = "Fiz"
307−divide8 5 = "Buz"
308−divide8 15 = "FizBuz"
309−divide8 _ = "Some other number"</code></pre>
310−
311− <p data-markdown>
312− Так матчить можно произвольные структуры произвольного уровня вложенности.
313−
314− `_` -- специальное название константы, которое говорит что вам все равно что в ней лежит.
315− </p>
316− <aside class="notes" data-markdown>
317− функции объявляются в несколькро строк. Первая -- обьявленик типа функции,
318− а последубщие -- реализация. В общем случае тип можно не указывать, но указывать тип у высказыванй на самом
319− верхнем уровне (не вложенные) считается хорошим тоном и улучшает выведение типов и ошибки компиляции.
320−
321− У функции может быть несколько реализаций: какая из них вызовется зависит от значений передаваемых
322− аргументов. матчинг произхводится сверху вниз.
323−
324− если в аргемантах написано слово с маленькой буквы, то значение аргумента биндится на эту константу.
325− </aside>
326− </section>
327− </section>
328− <section>
329− <section>
330− <h2>Структуры</h2>
331− </section>
332− <section>
333− <pre><code class="haskell">data Foo = Bar
334−foo :: Bar
335−foo = Bar</code></pre>
336−
337− <p data-markdown>
338− `Foo` -- тип структуры. `Bar` -- конструктор структуры.
339−
340− Тут у `Foo` всего одно значение `Bar`.
341− </p>
342− </section>
343− <section>
344− <h3>Произведение типов</h3>
345− <h5>(обычные поля структур)</h5>
346− <aside class="notes" data-markdown>
347− После констрктора можно укзать существующие типы, которые в нем храняться.
348− </aside>
349−
350− <pre><code class="haskell">data PersonType = Person String Int</code></pre>
351− <pre><code class="haskell fragment">vasya :: PersonType
352−vasya = Person "Vasya" 8
353−-- тип можно не укзывать
354−petya = Person "Petya" 5</code></pre>
355− <pre><code class="haskell fragment">getName :: PersonType -> String
356−getName (Person name _) = name</code></pre>
357− <pre><code class="haskell fragment">greetPerson :: PersonType -> String
358−greetPerson p = "Hello, " ++ getName p</code></pre>
359− <pre><code class="haskell fragment">greetPerson petya
360−-- "Hello, Petya"</code></pre>
361− </section>
362− <section>
363− <h3>Еще немного функций</h3>
364− <pre><code class="haskell fragment">greetPerson :: PersonType -> String
365−greetPerson p = "Hello, " ++ getName p</code></pre>
366−
367− <pre><code class="haskell fragment">greetPerson :: PersonType -> String
368−greetPerson p = "Hello, " ++ name
369− where
370− name = getName p</code></pre>
371− <pre><code class="haskell fragment">greetPerson :: PersonType -> String
372−greetPerson p = "Hello, " ++ name
373− where
374− getName' (Person name _) = name
375− name = getName' p</code></pre>
376− </section>
377− <section>
378− <pre><code class="haskell">data PersonType = Person String Int
379−
380−getName :: PersonType -> String
381−getName (Person name _) = name</code></pre>
382− <pre><code class="haskell fragment">greetName :: String -> String
383−greetName name = "Hello, " ++ name</code></pre>
384− <pre><code class="haskell fragment">greetPerson :: PersonType -> String
385−greetPerson p = greetName (getName p)</code></pre>
386− <pre><code class="haskell fragment">greetPerson :: PersonType -> String
387−greetPerson = greetName . getName</code></pre>
388− <pre><code class="haskell fragment">greetPerson petya
389−-- "Hello, Petya"</code></pre>
390− <pre><code class="haskell fragment">(greetName . getName) petya
391−-- "Hello, Petya"</code></pre>
392− </section>
393− <section>
394− <h3>Суммы типов</h3>
395− <aside class="notes" data-markdown>
396− Функции нескольких аргументов -- странный синтаксис -- потом расскажу.
397− </aside>
398−
399− <pre><code class="haskell fragment">data Bool = False | True</code></pre>
400− <pre><code class="haskell fragment">x :: Bool
401−x = True
402−y = False</code></pre>
403−
404− <pre><code class="haskell fragment">ifThenElse :: (Bool, a, a) -> a</code></pre>
405− <pre><code class="haskell fragment">ifThenElse (True, a, _) = a
406−ifThenElse (False, _, b) = b</code></pre>
407− <pre><code class="haskell fragment">ifThenElse (True, "Hello", "World")
408−-- "Hello"</code></pre>
409−
410− <pre><code class="haskell fragment">ifThenElse (False, "Hello", "World")
411−-- "World"</code></pre>
412−
413− </section>
414− <section>
415− <pre><code class="haskell">data CircleType = Circle Double Double Double
416−data RectangleType = Rectangle Double Double Double Double
417−</code></pre>
418− <pre><code class="haskell fragment">data Shape =
419− CircleShape CircleType | RectangleShape RectangleType</code></pre>
420− <pre><code class="haskell fragment">surface :: Shape -> Double</code></pre>
421− <pre><code class="haskell fragment">surface (CircleShape (Circle _ _ r)) =
422− pi * r ^ 2</code></pre>
423− <pre><code class="haskell fragment">surface (RectangleShape (Rectangle x1 y1 x2 y2)) =
424− (abs (x2 - x1)) * (abs (y2 - y1))</code></pre>
425− <pre><code class="haskell fragment">shape = CircleShape (Circle 0 0 2)
426−surface shape
427−-- 12.566370614359172
428−</code></pre>
429− <pre><code class="haskell fragment">otherShape = RectangleShape (Rectangle 1 2 3 4)
430−surface otherShape
431−-- 4.0
432−</code></pre>
433− </section>
434− </section>
435− <section>
436− <section>
437− <h2>И еще немного функций</h2>
438− </section>
439− <section>
440− <h3>Лямбда-выражения</h3>
441−
442− <pre><code class="haskell fragment">add8 :: Int -> Int</code></pre>
443− <pre><code class="haskell fragment">add8 x = x + 8</code></pre>
444− <pre><code class="haskell fragment">add8 = \x -> x + 8</code></pre>
445− <p data-markdown class="fragment">
446− λ -- `\`
447−
448− (λ печатать тяжело)</p>
449−
450− <pre><code class="haskell fragment">foo :: (Int -> Int) -> Int</code></pre>
451− <pre><code class="haskell fragment">foo add8</code></pre>
452− <pre><code class="haskell fragment">foo (\x -> x + 8)</code></pre>
453− </section>
454− <section>
455− <h3>Давайте придумаем синтаксис для функции нескольких аргументов!</h3>
456− </section>
457− <section>
458− <pre><code class="haskell">x, y :: Int
459−x = 42
460−y = 69
461−</code></pre>
462−
463− <pre><code class="haskell fragment">xPlusY :: Int
464−xPlusY = add x y</code></pre>
465− <p class="fragment" data-markdown>Применение функции -- лево-ассоциативно</p>
466− <pre><code class="haskell fragment">xPlusY = (add x) y</code></pre>
467− <pre><code class="haskell fragment">xPlusY = f y
468−f = add x</code></pre>
469− <pre><code class="haskell fragment">f :: Int -> Int</code></pre>
470− <pre><code class="haskell fragment">add :: Int -> (Int -> Int)</code></pre>
471− </section>
472− <section>
473− <pre><code class="haskell">add :: Int -> (Int -> Int)</code></pre>
474− <p class="fragment" data-markdown>Тип `->` -- право-ассоциативный</p>
475−
476− <pre><code class="haskell fragment">add :: Int -> Int -> Int</code></pre>
477− <pre><code class="haskell fragment">add a b = a + b</code></pre>
478− <pre><code class="haskell fragment">add = \a b -> a + b</code></pre>
479− </section>
480− <section>
481− <p>Любая функция берет строго один аргумент.</p>
482−
483− <p>Функция нескольких аргументов все равно берет строго одтн аргумент и возвращает функцию, которая берет
484− следйющий.
485− </p>
486−
487− <p>
488− <em>
489− (И из-за того, что применение функции лево-ассоциативно, вызов таких не трубует особого
490− синтаксиса.)
491− </em>
492− </p>
493− </section>
494− <section>
495− <h3>Currying</h3>
496− <pre><code class="haskell fragment">add :: Int -> Int -> Int
497−add a b = a + b</code></pre>
498−
499− <pre><code class="haskell fragment">add8 :: Int -> Int</code></pre>
500− <pre><code class="haskell fragment">add :: Int -> (Int -> Int)</code></pre>
501− <pre><code class="haskell fragment">add8 = add 8</code></pre>
502− <pre><code class="haskell fragment">add8 3
503−-- 11</code></pre>
504− </section>
505− <section>
506− <h3>Funny fact</h3>
507−
508− <p class="fragment" data-markdown>Оператор (например `+`) -- функция, название которой не содержит буквы и
509− цифры.</p>
510− <pre><code class="haskell fragment">x +&+ y = x + y</code></pre>
511− <pre><code class="haskell fragment">8 +&+ 9
512−-- 17</code></pre>
513−
514− </section>
515− <section>
516− <h3>Funny fact 2</h3>
517−
518− <p class="fragment" data-markdown>Оператор можно превратить в функцию, окружив его скобками.</p>
519− <pre><code class="haskell fragment">add :: Int -> Int -> Int
520−add x y = x + y</code></pre>
521− <pre><code class="haskell fragment">add = (+&+)</code></pre>
522− <pre><code class="haskell fragment">add = (+)</code></pre>
523−
524− </section>
525− <section>
526− <h3>Funny fact 3</h3>
527−
528− <p class="fragment" data-markdown>Функцию можно превратить в оператор, окружив ее обратными кавычками.</p>
529− <pre><code class="haskell fragment">add :: Int -> Int -> Int
530−add x y = x + y</code></pre>
531− <pre><code class="haskell fragment">add 8 9
532−-- 17</code></pre>
533− <pre><code class="haskell fragment">8 `add` 9
534−-- 17</code></pre>
535− </section>
536− </section>
537− </section>
538− <section>
539− <section>
540− <h2>Список</h2>
541− </section>
542− <section>
543− <h3>Односвязный список</h3>
544− <pre><code class="haskell fragment">data IntList = Cons Int IntList | Nil</code></pre>
545− <pre><code class="haskell fragment">nums :: IntList
546−nums = 1 `Cons` (2 `Cons` (3 `Cons` Nil))</code></pre>
547− <pre><code class="haskell fragment">sum :: IntList -> Int</code></pre>
548− <pre><code class="haskell fragment">sum (Cons x xs) = x + sum xs</code></pre>
549− <pre><code class="haskell fragment">sum Nil = 0
550−sum (Cons x xs) = x + sum xs</code></pre>
551− <pre><code class="haskell fragment">sum nums
552−-- 6</code></pre>
553−
554− </section>
555− <section>
556− <pre><code class="haskell">take :: Int -> IntList -> IntList</code></pre>
557− <pre><code class="haskell fragment">take _ Nil = Nil
558−take 0 _ = Nil
559−take n (Cons x xs) = Cons x (take (n - 1) xs)</code></pre>
560− <pre><code class="haskell fragment">nums :: IntList
561−nums = 1 `Cons` (2 `Cons` (3 `Cons` Nil))</code></pre>
562− <pre><code class="haskell fragment">take 2 nums
563−-- Cons 1 (Cons 2 Nil)
564−take 1029 nums
565−-- Cons 1 (Cons 2 (Cons 3 Nil))
566−take 0 nums
567−-- Nil</code></pre>
568−
569− </section>
570− <section>
571− <pre><code class="haskell">repeat :: Int -> IntList</code></pre>
572− <pre><code class="haskell fragment">repeat n = n : (repeat n)</code></pre>
573− <pre><code class="haskell fragment">repeat 8
574−-- Cons 8 (Cons 8 (Cons 8 (Cons 8 (Cons 8 (Cons 8 (Cons 8 (Cons 8 (Cons 8 (Cons 8 (...</code></pre>
575− <pre><code class="haskell fragment">(take 3 . repeat) 8
576−-- Cons 8 (Cons 8 (Cons 8 Nil))</code></pre>
577− <pre><code class="haskell fragment">(sum . take 3 . repeat) 8
578−-- 24</code></pre>
579− </section>
580− <section>
581− <table>
582− <tr>
583− <td>Наша самодеятельность</td>
584− <td>В стандартной библиотеке</td>
585− </tr>
586− <tr class="fragment">
587− <td>
588− <pre><code class="haskell">IntList</code></pre>
589− </td>
590− <td>
591− <pre><code class="haskell">[Int]</code></pre>
592− </td>
593− </tr>
594− <tr class="fragment">
595− <td>
596− <pre><code class="haskell">Nil</code></pre>
597− </td>
598− <td>
599− <pre><code class="haskell">[]</code></pre>
600− </td>
601− </tr>
602− <tr class="fragment">
603− <td>
604− <pre><code class="haskell">Cons</code></pre>
605− </td>
606− <td>
607− <pre><code class="haskell">:</code></pre>
608− </td>
609− </tr>
610− <tr class="fragment">
611− <td>
612− <pre><code class="haskell">Cons 3 (Cons 4 Nil)</code></pre>
613− </td>
614− <td>
615− <pre class="fragment"><code class="haskell">3 : 4 : []</code></pre>
616− <pre class="fragment"><code class="haskell">[3, 4]</code></pre>
617− </td>
618− </tr>
619− </table>
620− </section>
621− <section>
622− <p data-markdown>`repeat`, `sum` и `take` тоже есть в стандартной библиотеке.</p>
623− </section>
624− </section>
625− <section>
626− <section>
627− <h2>QuickSort</h2>
628− </section>
629− <section>
630− <pre><code class="haskell">quicksort :: [Int] -> [Int]</code></pre>
631−
632− <pre><code class="haskell fragment">quicksort (x:xs) =
633− quicksort smaller ++ [x] ++ quicksort larger
634− where
635− smaller = filter (< x) xs
636− larger = filter (>= x) xs</code></pre>
637− </section>
638− <section>
639− <pre><code class="haskell">filter :: (Bool -> Int) -> [Int] -> [Int]</code></pre>
640− <pre><code class="haskell fragment">filter f (x:xs) =
641− if f x
642− then filter f xs
643− else x:(filter f xs)</code></pre>
644− <pre><code class="haskell fragment">filter _ [] = []
645−filter f (x:xs) =
646− if f x
647− then filter f xs
648− else x:(filter f xs)</code></pre>
649− </section>
650− <section>
651− <pre><code class="haskell">quicksort :: [Int] -> [Int]
652−quicksort (x:xs) =
653− quicksort smaller ++ [x] ++ quicksort larger
654− where
655− smaller = filter (< x) xs
656− larger = filter (>= x) xs
657− filter _ [] = []
658− filter f (x:xs) =
659− if f x
660− then filter f xs
661− else x:(filter f xs)</code></pre>
662− </section>
663− <section>
664− <pre><code class="haskell">quicksort :: [Int] -> [Int]
665−quicksort [] = []
666−quicksort (x:xs) =
667− quicksort smaller ++ [x] ++ quicksort larger
668− where
669− smaller = filter (< x) xs
670− larger = filter (>= x) xs
671− filter _ [] = []
672− filter f (x:xs) =
673− if f x
674− then filter f xs
675− else x:(filter f xs)</code></pre>
676− <pre><code class="haskell fragment">quicksort [2, 1, 3, 4]
677−-- [1, 2, 3, 4]</code></pre>
678− </section>
679− <section>
680− <p data-markdown>`filter` тоже есть в стандартной библиотеке.</p>
681− </section>
682− </section>
683− <section>
684− <section>
685− <h2>Где и как смотреть "стандартную библиотеку"</h2>
686− </section>
687− <section>
688− <ol>
689− <li>
690− <a href="https://hackage.haskell.org/package/base">Hackage</a>
691−
692− <p data-markdown>
693− (Там вам нужен только пакет `base`. Ссылка ведет прямо на него.)
694−
695− Еще если там нажать `s`, то будет поиск.
696− </p>
697− </li>
698− <li class="fragment">
699− <a href="https://hoogle.haskell.org">Hoogle</a>
700−
701− <p data-markdown>
702− Это поиск по типам.
703−
704− Например: `Int -> [Int] -> [Int]`
705−
706− (Тут вам опять же нужен только пакет `base`. Нужно чтобы справа было "package:base".)
707−
708− </p>
709− </li>
710− </ol>
711− </section>
712− </section>
113+
114+
115+<section id="функциональное-программирование" class="slide level1">
116+<h1>Функциональное программирование</h1>
117+<aside class="notes">
118+<p>Функциональное программирование это не про использование map filter reduce. Функциональное программирование это вообще ортогонально к ооп. ИМХО проблема с ООП – наследование (которое тоже ортогонально к ООП) – нет разграничения между абстракцией и реализацией. и вообще обзывание это функциональным программированием – не совсем правильно. то, что мы сейчас будем пытаться сделать – сделать код более переиспользуемым. сделать наши данные максимально тупыми => переиспользуемыми. пытаться комбинировать слишком умные куски – не получится – слишком сложно. мы хотим сделать простые куски, которые просто комбинировать и еще чтобы компилятор проверял эти наши комбинации на валидность.</p>
119+</aside>
120+</section>
121+<section class="slide level1">
122+
123+<p>Функциональное программирование:</p>
124+<blockquote>
125+<p>функции – это тоже данные.</p>
126+</blockquote>
127+<p><code>Int -> Bool</code> (функция) – ровно такие же данные как и <code>Int</code>. Их также можно складывать в структуры, передавать как аргументы и т. п.</p>
128+</section>
129+<section id="нотация" class="slide level1">
130+<h1>нотация</h1>
131+</section>
132+<section class="slide level1">
133+
134+<table width="100%">
135+<tr>
136+<td>
137+<div class="sourceCode" id="cb1"><pre class="sourceCode java"><code class="sourceCode java"><span id="cb1-1"><a href="#cb1-1"></a> <span class="dt">int</span> x;</span></code></pre></div>
138+</td>
139+<td>
140+<div class="sourceCode" id="cb2"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb2-1"><a href="#cb2-1"></a><span class="ot"> x ::</span> <span class="dt">Int</span></span></code></pre></div>
141+</td>
142+</tr>
143+<tr class="fragment">
144+<td>
145+<div class="sourceCode" id="cb3"><pre class="sourceCode java"><code class="sourceCode java"><span id="cb3-1"><a href="#cb3-1"></a> <span class="dt">int</span> <span class="fu">f</span>(<span class="dt">int</span> x)</span></code></pre></div>
146+</td>
147+<td>
148+<div class="sourceCode" id="cb4"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb4-1"><a href="#cb4-1"></a><span class="ot"> f ::</span> <span class="dt">Int</span> <span class="ot">-></span> <span class="dt">Int</span></span></code></pre></div>
149+</td>
150+</tr>
151+<tr class="fragment">
152+<td>
153+<div class="sourceCode" id="cb5"><pre class="sourceCode java"><code class="sourceCode java"><span id="cb5-1"><a href="#cb5-1"></a> <span class="dt">static</span> <T> T <span class="fu">f</span>(T x)</span></code></pre></div>
154+</td>
155+<td>
156+<div class="sourceCode" id="cb6"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb6-1"><a href="#cb6-1"></a><span class="ot"> f ::</span> a <span class="ot">-></span> a</span></code></pre></div>
157+</td>
158+</tr>
159+</table>
160+</section>
161+<section class="slide level1">
162+
163+<table width="100%">
164+<tr>
165+<td>
166+<div class="sourceCode" id="cb7"><pre class="sourceCode java"><code class="sourceCode java"><span id="cb7-1"><a href="#cb7-1"></a> <span class="dt">static</span> <T> T <span class="fu">f</span>(T x)</span></code></pre></div>
167+</td>
168+<td>
169+<div class="sourceCode" id="cb8"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb8-1"><a href="#cb8-1"></a><span class="ot"> f ::</span> a <span class="ot">-></span> a</span></code></pre></div>
170+</td>
171+</tr>
172+<tr>
173+<td class="fragment">
174+<div class="sourceCode" id="cb9"><pre class="sourceCode java"><code class="sourceCode java"><span id="cb9-1"><a href="#cb9-1"></a> <span class="fu">f</span>(x);</span></code></pre></div>
175+</td>
176+<td class="fragment">
177+<div class="sourceCode" id="cb10"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb10-1"><a href="#cb10-1"></a> f x</span></code></pre></div>
178+</td>
179+</tr>
180+<tr class="fragment">
181+<td>
182+<div class="sourceCode" id="cb11"><pre class="sourceCode java"><code class="sourceCode java"><span id="cb11-1"><a href="#cb11-1"></a> <span class="fu">f</span>(x, y);</span></code></pre></div>
183+</td>
184+<td>
185+<div class="sourceCode" id="cb12"><pre class="sourceCode fragment haskell"><code class="sourceCode haskell"><span id="cb12-1"><a href="#cb12-1"></a> f x y</span></code></pre></div>
186+<div class="sourceCode" id="cb13"><pre class="sourceCode fragment haskell"><code class="sourceCode haskell"><span id="cb13-1"><a href="#cb13-1"></a> f x y <span class="ot">=</span> (f x) y</span></code></pre></div>
187+</td>
188+</td>
189+</tr>
190+</table>
191+<aside class="notes">
192+<p>Left-associative Currying</p>
193+</aside>
194+</section>
195+<section class="slide level1">
196+
197+<table width="100%">
198+<tr>
199+<td>
200+<div class="sourceCode" id="cb14"><pre class="sourceCode java"><code class="sourceCode java"><span id="cb14-1"><a href="#cb14-1"></a> <span class="dt">static</span> <T> T <span class="fu">f</span>(T x)</span>
201+<span id="cb14-2"><a href="#cb14-2"></a> <span class="dt">static</span> <T> T <span class="fu">g</span>(T x)</span></code></pre></div>
202+</td>
203+<td>
204+<div class="sourceCode" id="cb15"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb15-1"><a href="#cb15-1"></a><span class="ot"> f ::</span> a <span class="ot">-></span> a</span>
205+<span id="cb15-2"><a href="#cb15-2"></a><span class="ot"> g ::</span> a <span class="ot">-></span> a</span></code></pre></div>
206+</td>
207+</tr>
208+<tr>
209+<td class="fragment">
210+<div class="sourceCode" id="cb16"><pre class="sourceCode java"><code class="sourceCode java"><span id="cb16-1"><a href="#cb16-1"></a> <span class="fu">f</span>(<span class="fu">g</span>(x));</span>
211+<span id="cb16-2"><a href="#cb16-2"></a> <span class="fu">g</span>(<span class="fu">f</span>(x));</span></code></pre></div>
212+</td>
213+<td class="fragment">
214+<div class="sourceCode" id="cb17"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb17-1"><a href="#cb17-1"></a> f (g x)</span>
215+<span id="cb17-2"><a href="#cb17-2"></a> g (f x)</span></code></pre></div>
216+</td>
217+</tr>
218+</table>
219+</section>
220+<section id="композиция" class="slide level1">
221+<h1>Композиция</h1>
222+</section>
223+<section class="slide level1">
224+
225+<div class="sourceCode" id="cb18"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb18-1"><a href="#cb18-1"></a><span class="ot">f ::</span> a <span class="ot">-></span> a</span>
226+<span id="cb18-2"><a href="#cb18-2"></a><span class="ot">g ::</span> a <span class="ot">-></span> a</span></code></pre></div>
227+<div class="sourceCode" id="cb19"><pre class="sourceCode fragment haskell"><code class="sourceCode haskell"><span id="cb19-1"><a href="#cb19-1"></a>f (g x)</span></code></pre></div>
228+<div class="sourceCode" id="cb20"><pre class="sourceCode fragment haskell"><code class="sourceCode haskell"><span id="cb20-1"><a href="#cb20-1"></a>(f <span class="op">.</span> g) x <span class="op">==</span> f (g x)</span></code></pre></div>
229+<div class="sourceCode" id="cb21"><pre class="sourceCode fragment haskell"><code class="sourceCode haskell"><span id="cb21-1"><a href="#cb21-1"></a>h <span class="ot">=</span> f <span class="op">.</span> g</span>
230+<span id="cb21-2"><a href="#cb21-2"></a>h x <span class="op">==</span> f (g x)</span></code></pre></div>
231+</section>
232+<section class="slide level1">
233+
234+<div class="sourceCode" id="cb22"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb22-1"><a href="#cb22-1"></a><span class="ot">f ::</span> a <span class="ot">-></span> a</span>
235+<span id="cb22-2"><a href="#cb22-2"></a><span class="ot">g ::</span> a <span class="ot">-></span> a</span></code></pre></div>
236+<div class="sourceCode" id="cb23"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb23-1"><a href="#cb23-1"></a><span class="ot">h ::</span> a <span class="ot">-></span> a</span>
237+<span id="cb23-2"><a href="#cb23-2"></a>h <span class="ot">=</span> f <span class="op">.</span> g</span></code></pre></div>
238+<h3 class="fragment" id="моноид" class="fragment">моноид</h3>
239+<aside class="notes">
240+<p>моноид – у тебя есть две штуки одного типа и ты можешь получить еще одну штуку такого же типа. Это очень простой способ рождения сложности из простоты причем тип h выводится из определения. Нам его указывать не надо. если у нас изначальные маленькие кусочки хорошо описаны, то порожденные большие кусочки будут автоматически хорошо описанными.</p>
241+</aside>
242+</section>
243+<section class="slide level1">
244+
245+<h2 id="моноид-1">Моноид</h2>
246+<p><span class="fragment">Бинарная асоциативная операция</span></p>
247+<div class="sourceCode" id="cb24"><pre class="sourceCode fragment haskell"><code class="sourceCode haskell"><span id="cb24-1"><a href="#cb24-1"></a><span class="ot">(.) ::</span> (a <span class="ot">-></span> a) <span class="ot">-></span> (a <span class="ot">-></span> a) <span class="ot">-></span> (a <span class="ot">-></span> a)</span></code></pre></div>
248+<p><span class="fragment">Нейтральный элемент</span></p>
249+<div class="sourceCode" id="cb25"><pre class="sourceCode fragment haskell"><code class="sourceCode haskell"><span id="cb25-1"><a href="#cb25-1"></a><span class="fu">id</span><span class="ot"> ::</span> a <span class="ot">-></span> a</span>
250+<span id="cb25-2"><a href="#cb25-2"></a><span class="fu">id</span> x <span class="ot">=</span> x</span></code></pre></div>
251+</section>
252+<section id="haskell" class="slide level1">
253+<h1>Haskell</h1>
254+</section>
255+<section class="slide level1">
256+
257+<h3 id="чисто-функционаьлный">Чисто функционаьлный</h3>
258+<p>Все что функция может сделать – посмотреть на свои аргументы это вернуть значение.</p>
259+<aside class="notes">
260+<p>Нельзя просто произвольно распечатать строку в консоль, нельзя просто произвольно отправить запрос на бд, нельзя просто произвольно изменить глобальную переменную.</p>
261+</aside>
262+</section>
263+<section class="slide level1">
264+
265+<h3 id="referential-transparency">Referential transparency</h3>
266+<h5 id="любую-константу-можно-заменить-на-само-значение">(Любую константу можно заменить на само значение)</h5>
267+<div class="sourceCode" id="cb26"><pre class="sourceCode java fragment"><code class="sourceCode java"><span id="cb26-1"><a href="#cb26-1"></a><span class="dt">int</span> x = <span class="dv">8</span>;</span>
268+<span id="cb26-2"><a href="#cb26-2"></a><span class="dt">int</span> y = x++;</span>
269+<span id="cb26-3"><a href="#cb26-3"></a><span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">println</span>(y + <span class="st">" might be the same as "</span> + y);</span></code></pre></div>
270+<div class="sourceCode" id="cb27"><pre class="sourceCode java fragment"><code class="sourceCode java"><span id="cb27-1"><a href="#cb27-1"></a><span class="dt">int</span> x = <span class="dv">8</span>;</span>
271+<span id="cb27-2"><a href="#cb27-2"></a><span class="bu">System</span>.<span class="fu">out</span>.<span class="fu">println</span>(x++ + <span class="st">" might be the same as "</span> + x++);</span></code></pre></div>
272+<aside class="notes">
273+<p>Сильно упрощает рефакторинг и понимание кода.</p>
274+</aside>
275+</section>
276+<section class="slide level1">
277+
278+<h3 id="нет-переменных-циклов-и-условных-переходов">Нет переменных, циклов и условных переходов</h3>
279+<p><span class="fragment">Зато есть константы и нормальная рекурсия (А переходов вообще нет)</span></p>
280+</section>
281+<section class="slide level1">
282+
283+<h3 id="очень-ленивый">Очень ленивый</h3>
284+<div class="sourceCode" id="cb28"><pre class="sourceCode haskell fragment"><code class="sourceCode haskell"><span id="cb28-1"><a href="#cb28-1"></a>xs <span class="ot">=</span> [<span class="dv">4</span>, <span class="dv">1</span>, <span class="dv">3</span>, <span class="dv">2</span>]</span>
285+<span id="cb28-2"><a href="#cb28-2"></a>xs' <span class="ot">=</span> <span class="fu">sort</span> xs</span>
286+<span id="cb28-3"><a href="#cb28-3"></a><span class="fu">print</span> xs</span></code></pre></div>
287+<div class="fragment">
288+<p><code>xs'</code> не нужен чтобы распечатать <code>xs</code>, поэтому сортироваться ничто не будет. (Зачем делать то, что можно не делать)</p>
289+</div>
290+</section>
291+<section class="slide level1">
292+
293+<p>Если хотите быстро и просто потыкаться, тут есть интерктивная штука:</p>
294+<p><a href="https://www.haskell.org">haskell.org</a></p>
295+</section>
296+<section id="синтаксис" class="slide level1">
297+<h1>Синтаксис</h1>
298+</section>
299+<section id="функции" class="slide level1">
300+<h1>Функции</h1>
301+</section>
302+<section class="slide level1">
303+
304+<div class="sourceCode" id="cb29"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb29-1"><a href="#cb29-1"></a><span class="ot">add2 ::</span> <span class="dt">Int</span> <span class="ot">-></span> <span class="dt">Int</span></span>
305+<span id="cb29-2"><a href="#cb29-2"></a>add2 x <span class="ot">=</span> x <span class="op">+</span> <span class="dv">2</span></span></code></pre></div>
306+<p>Все функции и константы всегда обозначаются словами с маленькой буквы без пробелов.</p>
307+<p>(Константы это просто функции с нулем аргументов.)</p>
308+</section>
309+<section class="slide level1">
310+
311+<h2 id="pattern-mathcing">Pattern mathcing</h2>
312+<div class="sourceCode" id="cb30"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb30-1"><a href="#cb30-1"></a><span class="ot">fixBuz ::</span> <span class="dt">Int</span> <span class="ot">-></span> <span class="dt">String</span></span>
313+<span id="cb30-2"><a href="#cb30-2"></a>divide8 <span class="dv">3</span> <span class="ot">=</span> <span class="st">"Fiz"</span></span>
314+<span id="cb30-3"><a href="#cb30-3"></a>divide8 <span class="dv">5</span> <span class="ot">=</span> <span class="st">"Buz"</span></span>
315+<span id="cb30-4"><a href="#cb30-4"></a>divide8 <span class="dv">15</span> <span class="ot">=</span> <span class="st">"FizBuz"</span></span>
316+<span id="cb30-5"><a href="#cb30-5"></a>divide8 _ <span class="ot">=</span> <span class="st">"Some other number"</span></span></code></pre></div>
317+<p>Так матчить можно произвольные структуры произвольного уровня вложенности.</p>
318+<p><code>_</code> – специальное название константы, которое говорит что вам все равно что в ней лежит.</p>
319+<aside class="notes">
320+<p>функции объявляются в несколькро строк. Первая – обьявленик типа функции, а последубщие – реализация. В общем случае тип можно не указывать, но указывать тип у высказыванй на самом верхнем уровне (не вложенные) считается хорошим тоном и улучшает выведение типов и ошибки компиляции. У функции может быть несколько реализаций: какая из них вызовется зависит от значений передаваемых аргументов. матчинг произхводится сверху вниз. если в аргемантах написано слово с маленькой буквы, то значение аргумента биндится на эту константу.</p>
321+</aside>
322+</section>
323+<section class="slide level1">
324+
325+<h2 id="структуры">Структуры</h2>
326+</section>
327+<section class="slide level1">
328+
329+<div class="sourceCode" id="cb31"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb31-1"><a href="#cb31-1"></a><span class="kw">data</span> <span class="dt">Foo</span> <span class="ot">=</span> <span class="dt">Bar</span></span>
330+<span id="cb31-2"><a href="#cb31-2"></a><span class="ot">foo ::</span> <span class="dt">Bar</span></span>
331+<span id="cb31-3"><a href="#cb31-3"></a>foo <span class="ot">=</span> <span class="dt">Bar</span></span></code></pre></div>
332+<p><code>Foo</code> – тип структуры. <code>Bar</code> – конструктор структуры.</p>
333+<p>Тут у <code>Foo</code> всего одно значение <code>Bar</code>.</p>
334+</section>
335+<section class="slide level1">
336+
337+<h2 id="произведение-типов">Произведение типов</h2>
338+<h5 id="обычные-поля-структур">(обычные поля структур)</h5>
339+<aside class="notes">
340+<p>После констрктора можно укзать существующие типы, которые в нем храняться.</p>
341+</aside>
342+<div class="sourceCode" id="cb32"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb32-1"><a href="#cb32-1"></a><span class="kw">data</span> <span class="dt">PersonType</span> <span class="ot">=</span> <span class="dt">Person</span> <span class="dt">String</span> <span class="dt">Int</span></span></code></pre></div>
343+<div class="sourceCode" id="cb33"><pre class="sourceCode haskell fragment"><code class="sourceCode haskell"><span id="cb33-1"><a href="#cb33-1"></a><span class="ot">vasya ::</span> <span class="dt">PersonType</span></span>
344+<span id="cb33-2"><a href="#cb33-2"></a>vasya <span class="ot">=</span> <span class="dt">Person</span> <span class="st">"Vasya"</span> <span class="dv">8</span></span>
345+<span id="cb33-3"><a href="#cb33-3"></a><span class="co">-- тип можно не укзывать</span></span>
346+<span id="cb33-4"><a href="#cb33-4"></a>petya <span class="ot">=</span> <span class="dt">Person</span> <span class="st">"Petya"</span> <span class="dv">5</span></span></code></pre></div>
347+<div class="sourceCode" id="cb34"><pre class="sourceCode haskell fragment"><code class="sourceCode haskell"><span id="cb34-1"><a href="#cb34-1"></a><span class="ot">getName ::</span> <span class="dt">PersonType</span> <span class="ot">-></span> <span class="dt">String</span></span>
348+<span id="cb34-2"><a href="#cb34-2"></a>getName (<span class="dt">Person</span> name _) <span class="ot">=</span> name</span></code></pre></div>
349+<div class="sourceCode" id="cb35"><pre class="sourceCode haskell fragment"><code class="sourceCode haskell"><span id="cb35-1"><a href="#cb35-1"></a><span class="ot">greetPerson ::</span> <span class="dt">PersonType</span> <span class="ot">-></span> <span class="dt">String</span></span>
350+<span id="cb35-2"><a href="#cb35-2"></a>greetPerson p <span class="ot">=</span> <span class="st">"Hello, "</span> <span class="op">++</span> getName p</span></code></pre></div>
351+<div class="sourceCode" id="cb36"><pre class="sourceCode haskell fragment"><code class="sourceCode haskell"><span id="cb36-1"><a href="#cb36-1"></a>greetPerson petya</span>
352+<span id="cb36-2"><a href="#cb36-2"></a><span class="co">-- "Hello, Petya"</span></span></code></pre></div>
353+</section>
354+<section class="slide level1">
355+
356+<h2 id="еще-немного-функций">Еще немного функций</h2>
357+<div class="sourceCode" id="cb37"><pre class="sourceCode haskell fragment"><code class="sourceCode haskell"><span id="cb37-1"><a href="#cb37-1"></a><span class="ot">greetPerson ::</span> <span class="dt">PersonType</span> <span class="ot">-></span> <span class="dt">String</span></span>
358+<span id="cb37-2"><a href="#cb37-2"></a>greetPerson p <span class="ot">=</span> <span class="st">"Hello, "</span> <span class="op">++</span> getName p</span></code></pre></div>
359+<div class="sourceCode" id="cb38"><pre class="sourceCode fragment haskell"><code class="sourceCode haskell"><span id="cb38-1"><a href="#cb38-1"></a><span class="ot">greetPerson ::</span> <span class="dt">PersonType</span> <span class="ot">-></span> <span class="dt">String</span></span>
360+<span id="cb38-2"><a href="#cb38-2"></a>greetPerson p <span class="ot">=</span> <span class="st">"Hello, "</span> <span class="op">++</span> name</span>
361+<span id="cb38-3"><a href="#cb38-3"></a> <span class="kw">where</span></span>
362+<span id="cb38-4"><a href="#cb38-4"></a> name <span class="ot">=</span> getName p</span></code></pre></div>
363+<div class="sourceCode" id="cb39"><pre class="sourceCode fragment haskell"><code class="sourceCode haskell"><span id="cb39-1"><a href="#cb39-1"></a><span class="ot">greetPerson ::</span> <span class="dt">PersonType</span> <span class="ot">-></span> <span class="dt">String</span></span>
364+<span id="cb39-2"><a href="#cb39-2"></a>greetPerson p <span class="ot">=</span> <span class="st">"Hello, "</span> <span class="op">++</span> name</span>
365+<span id="cb39-3"><a href="#cb39-3"></a> <span class="kw">where</span></span>
366+<span id="cb39-4"><a href="#cb39-4"></a> getName' (<span class="dt">Person</span> name _) <span class="ot">=</span> name</span>
367+<span id="cb39-5"><a href="#cb39-5"></a> name <span class="ot">=</span> getName' p</span></code></pre></div>
368+</section>
369+<section class="slide level1">
370+
371+<div class="sourceCode" id="cb40"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb40-1"><a href="#cb40-1"></a><span class="kw">data</span> <span class="dt">PersonType</span> <span class="ot">=</span> <span class="dt">Person</span> <span class="dt">String</span> <span class="dt">Int</span></span>
372+<span id="cb40-2"><a href="#cb40-2"></a></span>
373+<span id="cb40-3"><a href="#cb40-3"></a><span class="ot">getName ::</span> <span class="dt">PersonType</span> <span class="ot">-></span> <span class="dt">String</span></span>
374+<span id="cb40-4"><a href="#cb40-4"></a>getName (<span class="dt">Person</span> name _) <span class="ot">=</span> name</span></code></pre></div>
375+<div class="sourceCode" id="cb41"><pre class="sourceCode fragment haskell"><code class="sourceCode haskell"><span id="cb41-1"><a href="#cb41-1"></a><span class="ot">greetName ::</span> <span class="dt">String</span> <span class="ot">-></span> <span class="dt">String</span></span>
376+<span id="cb41-2"><a href="#cb41-2"></a>greetName name <span class="ot">=</span> <span class="st">"Hello, "</span> <span class="op">++</span> name</span></code></pre></div>
377+<div class="sourceCode" id="cb42"><pre class="sourceCode fragment haskell"><code class="sourceCode haskell"><span id="cb42-1"><a href="#cb42-1"></a><span class="ot">greetPerson ::</span> <span class="dt">PersonType</span> <span class="ot">-></span> <span class="dt">String</span></span>
378+<span id="cb42-2"><a href="#cb42-2"></a>greetPerson p <span class="ot">=</span> greetName (getName p)</span></code></pre></div>
379+<div class="sourceCode" id="cb43"><pre class="sourceCode fragment haskell"><code class="sourceCode haskell"><span id="cb43-1"><a href="#cb43-1"></a><span class="ot">greetPerson ::</span> <span class="dt">PersonType</span> <span class="ot">-></span> <span class="dt">String</span></span>
380+<span id="cb43-2"><a href="#cb43-2"></a>greetPerson <span class="ot">=</span> greetName <span class="op">.</span> getName</span></code></pre></div>
381+<div class="sourceCode" id="cb44"><pre class="sourceCode fragment haskell"><code class="sourceCode haskell"><span id="cb44-1"><a href="#cb44-1"></a>greetPerson petya</span>
382+<span id="cb44-2"><a href="#cb44-2"></a><span class="co">-- "Hello, Petya"</span></span></code></pre></div>
383+<div class="sourceCode" id="cb45"><pre class="sourceCode fragment haskell"><code class="sourceCode haskell"><span id="cb45-1"><a href="#cb45-1"></a>(greetName <span class="op">.</span> getName) petya</span>
384+<span id="cb45-2"><a href="#cb45-2"></a><span class="co">-- "Hello, Petya"</span></span></code></pre></div>
385+</section>
386+<section class="slide level1">
387+
388+<h2 id="суммы-типов">Суммы типов</h2>
389+<aside class="notes">
390+<p>Функции нескольких аргументов – странный синтаксис – потом расскажу. А пока используем тюпли!</p>
391+</aside>
392+<div class="sourceCode" id="cb46"><pre class="sourceCode fragment haskell"><code class="sourceCode haskell"><span id="cb46-1"><a href="#cb46-1"></a><span class="kw">data</span> <span class="dt">Bool</span> <span class="ot">=</span> <span class="dt">False</span> <span class="op">|</span> <span class="dt">True</span></span></code></pre></div>
393+<div class="sourceCode" id="cb47"><pre class="sourceCode fragment haskell"><code class="sourceCode haskell"><span id="cb47-1"><a href="#cb47-1"></a><span class="ot">x ::</span> <span class="dt">Bool</span></span>
394+<span id="cb47-2"><a href="#cb47-2"></a>x <span class="ot">=</span> <span class="dt">True</span></span>
395+<span id="cb47-3"><a href="#cb47-3"></a>y <span class="ot">=</span> <span class="dt">False</span></span></code></pre></div>
396+<div class="sourceCode" id="cb48"><pre class="sourceCode fragment haskell"><code class="sourceCode haskell"><span id="cb48-1"><a href="#cb48-1"></a><span class="ot">ifThenElse ::</span> (<span class="dt">Bool</span>, a, a) <span class="ot">-></span> a</span></code></pre></div>
397+<div class="sourceCode" id="cb49"><pre class="sourceCode fragment haskell"><code class="sourceCode haskell"><span id="cb49-1"><a href="#cb49-1"></a>ifThenElse (<span class="dt">True</span>, a, _) <span class="ot">=</span> a</span>
398+<span id="cb49-2"><a href="#cb49-2"></a>ifThenElse (<span class="dt">False</span>, _, b) <span class="ot">=</span> b</span></code></pre></div>
399+<div class="sourceCode" id="cb50"><pre class="sourceCode fragment haskell"><code class="sourceCode haskell"><span id="cb50-1"><a href="#cb50-1"></a>ifThenElse (<span class="dt">True</span>, <span class="st">"Hello"</span>, <span class="st">"World"</span>)</span>
400+<span id="cb50-2"><a href="#cb50-2"></a><span class="co">-- "Hello"</span></span></code></pre></div>
401+<div class="sourceCode" id="cb51"><pre class="sourceCode fragment haskell"><code class="sourceCode haskell"><span id="cb51-1"><a href="#cb51-1"></a>ifThenElse (<span class="dt">False</span>, <span class="st">"Hello"</span>, <span class="st">"World"</span>)</span>
402+<span id="cb51-2"><a href="#cb51-2"></a><span class="co">-- "World"</span></span></code></pre></div>
403+</section>
404+<section class="slide level1">
405+
406+<div class="sourceCode" id="cb52"><pre class="sourceCode fragment haskell"><code class="sourceCode haskell"><span id="cb52-1"><a href="#cb52-1"></a><span class="kw">data</span> <span class="dt">CircleType</span> <span class="ot">=</span> <span class="dt">Circle</span> <span class="dt">Double</span> <span class="dt">Double</span> <span class="dt">Double</span></span>
407+<span id="cb52-2"><a href="#cb52-2"></a><span class="kw">data</span> <span class="dt">RectangleType</span> <span class="ot">=</span> <span class="dt">Rectangle</span> <span class="dt">Double</span> <span class="dt">Double</span> <span class="dt">Double</span> <span class="dt">Double</span></span></code></pre></div>
408+<div class="sourceCode" id="cb53"><pre class="sourceCode fragment haskell"><code class="sourceCode haskell"><span id="cb53-1"><a href="#cb53-1"></a><span class="kw">data</span> <span class="dt">Shape</span> <span class="ot">=</span></span>
409+<span id="cb53-2"><a href="#cb53-2"></a> <span class="dt">CircleShape</span> <span class="dt">CircleType</span> <span class="op">|</span> <span class="dt">RectangleShape</span> <span class="dt">RectangleType</span></span></code></pre></div>
410+<div class="sourceCode" id="cb54"><pre class="sourceCode fragment haskell"><code class="sourceCode haskell"><span id="cb54-1"><a href="#cb54-1"></a><span class="ot">surface ::</span> <span class="dt">Shape</span> <span class="ot">-></span> <span class="dt">Double</span></span></code></pre></div>
411+<div class="sourceCode" id="cb55"><pre class="sourceCode fragment haskell"><code class="sourceCode haskell"><span id="cb55-1"><a href="#cb55-1"></a>surface (<span class="dt">CircleShape</span> (<span class="dt">Circle</span> _ _ r)) <span class="ot">=</span></span>
412+<span id="cb55-2"><a href="#cb55-2"></a> <span class="fu">pi</span> <span class="op">*</span> r <span class="op">^</span> <span class="dv">2</span></span></code></pre></div>
413+<div class="sourceCode" id="cb56"><pre class="sourceCode fragment haskell"><code class="sourceCode haskell"><span id="cb56-1"><a href="#cb56-1"></a>surface (<span class="dt">RectangleShape</span> (<span class="dt">Rectangle</span> x1 y1 x2 y2)) <span class="ot">=</span></span>
414+<span id="cb56-2"><a href="#cb56-2"></a> (<span class="fu">abs</span> (x2 <span class="op">-</span> x1)) <span class="op">*</span> (<span class="fu">abs</span> (y2 <span class="op">-</span> y1))</span></code></pre></div>
415+<div class="sourceCode" id="cb57"><pre class="sourceCode fragment haskell"><code class="sourceCode haskell"><span id="cb57-1"><a href="#cb57-1"></a>shape <span class="ot">=</span> <span class="dt">CircleShape</span> (<span class="dt">Circle</span> <span class="dv">0</span> <span class="dv">0</span> <span class="dv">2</span>)</span>
416+<span id="cb57-2"><a href="#cb57-2"></a>surface shape</span>
417+<span id="cb57-3"><a href="#cb57-3"></a><span class="co">-- 12.566370614359172</span></span></code></pre></div>
418+<div class="sourceCode" id="cb58"><pre class="sourceCode fragment haskell"><code class="sourceCode haskell"><span id="cb58-1"><a href="#cb58-1"></a>otherShape <span class="ot">=</span> <span class="dt">RectangleShape</span> (<span class="dt">Rectangle</span> <span class="dv">1</span> <span class="dv">2</span> <span class="dv">3</span> <span class="dv">4</span>)</span>
419+<span id="cb58-2"><a href="#cb58-2"></a>surface otherShape</span>
420+<span id="cb58-3"><a href="#cb58-3"></a><span class="co">-- 4.0</span></span></code></pre></div>
421+</section>
422+<section id="и-еще-немного-функций" class="slide level1">
423+<h1>И еще немного функций</h1>
424+</section>
425+<section class="slide level1">
426+
427+<h2 id="лямбда-выражения">Лямбда-выражения</h2>
428+<div class="sourceCode" id="cb59"><pre class="sourceCode haskell fragment"><code class="sourceCode haskell"><span id="cb59-1"><a href="#cb59-1"></a><span class="ot">add8 ::</span> <span class="dt">Int</span> <span class="ot">-></span> <span class="dt">Int</span></span></code></pre></div>
429+<div class="sourceCode" id="cb60"><pre class="sourceCode haskell fragment"><code class="sourceCode haskell"><span id="cb60-1"><a href="#cb60-1"></a>add8 x <span class="ot">=</span> x <span class="op">+</span> <span class="dv">8</span></span></code></pre></div>
430+<div class="sourceCode" id="cb61"><pre class="sourceCode haskell fragment"><code class="sourceCode haskell"><span id="cb61-1"><a href="#cb61-1"></a>add8 <span class="ot">=</span> \x <span class="ot">-></span> x <span class="op">+</span> <span class="dv">8</span></span></code></pre></div>
431+<p><span class="fragment">λ – <code>\</code> (λ печатать тяжело)</span></p>
432+<div class="sourceCode" id="cb62"><pre class="sourceCode haskell fragment"><code class="sourceCode haskell"><span id="cb62-1"><a href="#cb62-1"></a><span class="ot">foo ::</span> (<span class="dt">Int</span> <span class="ot">-></span> <span class="dt">Int</span>) <span class="ot">-></span> <span class="dt">Int</span></span></code></pre></div>
433+<div class="sourceCode" id="cb63"><pre class="sourceCode haskell fragment"><code class="sourceCode haskell"><span id="cb63-1"><a href="#cb63-1"></a>foo add8</span></code></pre></div>
434+<div class="sourceCode" id="cb64"><pre class="sourceCode haskell fragment"><code class="sourceCode haskell"><span id="cb64-1"><a href="#cb64-1"></a>foo (\x <span class="ot">-></span> x <span class="op">+</span> <span class="dv">8</span>)</span></code></pre></div>
435+</section>
436+<section class="slide level1">
437+
438+<h3 id="давайте-придумаем-синтаксис-для-функции-нескольких-аргументов">Давайте придумаем синтаксис для функции нескольких аргументов!</h3>
439+</section>
440+<section class="slide level1">
441+
442+<div class="sourceCode" id="cb65"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb65-1"><a href="#cb65-1"></a>x,<span class="ot"> y ::</span> <span class="dt">Int</span></span>
443+<span id="cb65-2"><a href="#cb65-2"></a>x <span class="ot">=</span> <span class="dv">42</span></span>
444+<span id="cb65-3"><a href="#cb65-3"></a>y <span class="ot">=</span> <span class="dv">69</span></span></code></pre></div>
445+<div class="sourceCode" id="cb66"><pre class="sourceCode haskell fragment"><code class="sourceCode haskell"><span id="cb66-1"><a href="#cb66-1"></a><span class="ot">xPlusY ::</span> <span class="dt">Int</span></span>
446+<span id="cb66-2"><a href="#cb66-2"></a>xPlusY <span class="ot">=</span> add x y</span></code></pre></div>
447+<p><span class="fragment">Применение функции – лево-ассоциативно</span></p>
448+<div class="sourceCode" id="cb67"><pre class="sourceCode haskell fragment"><code class="sourceCode haskell"><span id="cb67-1"><a href="#cb67-1"></a>xPlusY <span class="ot">=</span> (add x) y</span></code></pre></div>
449+<div class="sourceCode" id="cb68"><pre class="sourceCode haskell fragment"><code class="sourceCode haskell"><span id="cb68-1"><a href="#cb68-1"></a>xPlusY <span class="ot">=</span> f y</span>
450+<span id="cb68-2"><a href="#cb68-2"></a>f <span class="ot">=</span> add x</span></code></pre></div>
451+<div class="sourceCode" id="cb69"><pre class="sourceCode haskell fragment"><code class="sourceCode haskell"><span id="cb69-1"><a href="#cb69-1"></a><span class="ot">f ::</span> <span class="dt">Int</span> <span class="ot">-></span> <span class="dt">Int</span></span></code></pre></div>
452+<div class="sourceCode" id="cb70"><pre class="sourceCode haskell fragment"><code class="sourceCode haskell"><span id="cb70-1"><a href="#cb70-1"></a><span class="ot">add ::</span> <span class="dt">Int</span> <span class="ot">-></span> (<span class="dt">Int</span> <span class="ot">-></span> <span class="dt">Int</span>)</span></code></pre></div>
453+</section>
454+<section class="slide level1">
455+
456+<div class="sourceCode" id="cb71"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb71-1"><a href="#cb71-1"></a><span class="ot">add ::</span> <span class="dt">Int</span> <span class="ot">-></span> (<span class="dt">Int</span> <span class="ot">-></span> <span class="dt">Int</span>)</span></code></pre></div>
457+<p><span class="fragment">Тип <code>-></code> – право-ассоциативный</span></p>
458+<div class="sourceCode" id="cb72"><pre class="sourceCode haskell fragment"><code class="sourceCode haskell"><span id="cb72-1"><a href="#cb72-1"></a><span class="ot">add ::</span> <span class="dt">Int</span> <span class="ot">-></span> <span class="dt">Int</span> <span class="ot">-></span> <span class="dt">Int</span></span></code></pre></div>
459+<div class="sourceCode" id="cb73"><pre class="sourceCode haskell fragment"><code class="sourceCode haskell"><span id="cb73-1"><a href="#cb73-1"></a>add a b <span class="ot">=</span> a <span class="op">+</span> b</span></code></pre></div>
460+<div class="sourceCode" id="cb74"><pre class="sourceCode haskell fragment"><code class="sourceCode haskell"><span id="cb74-1"><a href="#cb74-1"></a>add <span class="ot">=</span> \a b <span class="ot">-></span> a <span class="op">+</span> b</span></code></pre></div>
461+</section>
462+<section class="slide level1">
463+
464+<p>Любая функция берет строго один аргумент.</p>
465+<p>Функция нескольких аргументов все равно берет строго одтн аргумент и возвращает функцию, которая берет следйющий.</p>
466+<p><em>(И из-за того, что применение функции лево-ассоциативно, вызов таких не трубует особого синтаксиса.)</em></p>
467+</section>
468+<section class="slide level1">
469+
470+<h3 id="currying">Currying</h3>
471+<div class="sourceCode" id="cb75"><pre class="sourceCode haskell fragment"><code class="sourceCode haskell"><span id="cb75-1"><a href="#cb75-1"></a><span class="ot">add ::</span> <span class="dt">Int</span> <span class="ot">-></span> <span class="dt">Int</span> <span class="ot">-></span> <span class="dt">Int</span></span>
472+<span id="cb75-2"><a href="#cb75-2"></a>add a b <span class="ot">=</span> a <span class="op">+</span> b</span></code></pre></div>
473+<div class="sourceCode" id="cb76"><pre class="sourceCode haskell fragment"><code class="sourceCode haskell"><span id="cb76-1"><a href="#cb76-1"></a><span class="ot">add8 ::</span> <span class="dt">Int</span> <span class="ot">-></span> <span class="dt">Int</span></span></code></pre></div>
474+<div class="sourceCode" id="cb77"><pre class="sourceCode haskell fragment"><code class="sourceCode haskell"><span id="cb77-1"><a href="#cb77-1"></a><span class="ot">add ::</span> <span class="dt">Int</span> <span class="ot">-></span> (<span class="dt">Int</span> <span class="ot">-></span> <span class="dt">Int</span>)</span></code></pre></div>
475+<div class="sourceCode" id="cb78"><pre class="sourceCode haskell fragment"><code class="sourceCode haskell"><span id="cb78-1"><a href="#cb78-1"></a>add8 <span class="ot">=</span> add <span class="dv">8</span></span></code></pre></div>
476+<div class="sourceCode" id="cb79"><pre class="sourceCode haskell fragment"><code class="sourceCode haskell"><span id="cb79-1"><a href="#cb79-1"></a>add8 <span class="dv">3</span></span>
477+<span id="cb79-2"><a href="#cb79-2"></a><span class="co">-- 11</span></span></code></pre></div>
478+</section>
479+<section class="slide level1">
480+
481+<h3 id="funny-fact">Funny fact</h3>
482+<p><span class="fragment">Оператор (например <code>+</code>) – функция, название которой не содержит буквы и цифры.</span></p>
483+<div class="sourceCode" id="cb80"><pre class="sourceCode haskell fragment"><code class="sourceCode haskell"><span id="cb80-1"><a href="#cb80-1"></a>x <span class="op">+&+</span> y <span class="ot">=</span> x <span class="op">+</span> y</span></code></pre></div>
484+<div class="sourceCode" id="cb81"><pre class="sourceCode haskell fragment"><code class="sourceCode haskell"><span id="cb81-1"><a href="#cb81-1"></a><span class="dv">8</span> <span class="op">+&+</span> <span class="dv">9</span></span>
485+<span id="cb81-2"><a href="#cb81-2"></a><span class="co">-- 17</span></span></code></pre></div>
486+</section>
487+<section class="slide level1">
488+
489+<h3 id="funny-fact-2">Funny fact 2</h3>
490+<p><span class="fragment">Оператор можно превратить в функцию, окружив его скобками.</span></p>
491+<div class="sourceCode" id="cb82"><pre class="sourceCode haskell fragment"><code class="sourceCode haskell"><span id="cb82-1"><a href="#cb82-1"></a><span class="ot">add ::</span> <span class="dt">Int</span> <span class="ot">-></span> <span class="dt">Int</span> <span class="ot">-></span> <span class="dt">Int</span></span>
492+<span id="cb82-2"><a href="#cb82-2"></a>add x y <span class="ot">=</span> x <span class="op">+</span> y</span></code></pre></div>
493+<div class="sourceCode" id="cb83"><pre class="sourceCode haskell fragment"><code class="sourceCode haskell"><span id="cb83-1"><a href="#cb83-1"></a>add <span class="ot">=</span> (<span class="op">+&+</span>)</span></code></pre></div>
494+<div class="sourceCode" id="cb84"><pre class="sourceCode haskell fragment"><code class="sourceCode haskell"><span id="cb84-1"><a href="#cb84-1"></a>add <span class="ot">=</span> (<span class="op">+</span>)</span></code></pre></div>
495+</section>
496+<section class="slide level1">
497+
498+<h3 id="funny-fact-3">Funny fact 3</h3>
499+<p><span class="fragment">Функцию можно превратить в оператор, окружив ее обратными кавычками.</span></p>
500+<div class="sourceCode" id="cb85"><pre class="sourceCode haskell fragment"><code class="sourceCode haskell"><span id="cb85-1"><a href="#cb85-1"></a><span class="ot">add ::</span> <span class="dt">Int</span> <span class="ot">-></span> <span class="dt">Int</span> <span class="ot">-></span> <span class="dt">Int</span></span>
501+<span id="cb85-2"><a href="#cb85-2"></a>add x y <span class="ot">=</span> x <span class="op">+</span> y</span></code></pre></div>
502+<div class="sourceCode" id="cb86"><pre class="sourceCode haskell fragment"><code class="sourceCode haskell"><span id="cb86-1"><a href="#cb86-1"></a>add <span class="dv">8</span> <span class="dv">9</span></span>
503+<span id="cb86-2"><a href="#cb86-2"></a><span class="co">-- 17</span></span></code></pre></div>
504+<div class="sourceCode" id="cb87"><pre class="sourceCode haskell fragment"><code class="sourceCode haskell"><span id="cb87-1"><a href="#cb87-1"></a><span class="dv">8</span> <span class="ot">`add`</span> <span class="dv">9</span></span>
505+<span id="cb87-2"><a href="#cb87-2"></a><span class="co">-- 17</span></span></code></pre></div>
506+</section>
507+<section id="список" class="slide level1">
508+<h1>Список</h1>
509+</section>
510+<section class="slide level1">
511+
512+<h3 id="односвязный-список">Односвязный список</h3>
513+<div class="sourceCode" id="cb88"><pre class="sourceCode haskell fragment"><code class="sourceCode haskell"><span id="cb88-1"><a href="#cb88-1"></a><span class="kw">data</span> <span class="dt">IntList</span> <span class="ot">=</span> <span class="dt">Cons</span> <span class="dt">Int</span> <span class="dt">IntList</span> <span class="op">|</span> <span class="dt">Nil</span></span></code></pre></div>
514+<div class="sourceCode" id="cb89"><pre class="sourceCode haskell fragment"><code class="sourceCode haskell"><span id="cb89-1"><a href="#cb89-1"></a><span class="dt">Cons</span><span class="ot"> ::</span> <span class="dt">Int</span> <span class="ot">-></span> <span class="dt">IntList</span> <span class="ot">-></span> <span class="dt">IntList</span></span>
515+<span id="cb89-2"><a href="#cb89-2"></a><span class="dt">Nil</span><span class="ot"> ::</span> <span class="dt">IntList</span></span></code></pre></div>
516+<div class="sourceCode" id="cb90"><pre class="sourceCode haskell fragment"><code class="sourceCode haskell"><span id="cb90-1"><a href="#cb90-1"></a><span class="ot">nums ::</span> <span class="dt">IntList</span></span>
517+<span id="cb90-2"><a href="#cb90-2"></a>nums <span class="ot">=</span> <span class="dv">1</span> <span class="ot">`Cons`</span> (<span class="dv">2</span> <span class="ot">`Cons`</span> (<span class="dv">3</span> <span class="ot">`Cons`</span> <span class="dt">Nil</span>))</span></code></pre></div>
518+<div class="sourceCode" id="cb91"><pre class="sourceCode haskell fragment"><code class="sourceCode haskell"><span id="cb91-1"><a href="#cb91-1"></a><span class="fu">sum</span><span class="ot"> ::</span> <span class="dt">IntList</span> <span class="ot">-></span> <span class="dt">Int</span></span></code></pre></div>
519+<div class="sourceCode" id="cb92"><pre class="sourceCode haskell fragment"><code class="sourceCode haskell"><span id="cb92-1"><a href="#cb92-1"></a><span class="fu">sum</span> (<span class="dt">Cons</span> x xs) <span class="ot">=</span> x <span class="op">+</span> <span class="fu">sum</span> xs</span></code></pre></div>
520+<div class="sourceCode" id="cb93"><pre class="sourceCode haskell fragment"><code class="sourceCode haskell"><span id="cb93-1"><a href="#cb93-1"></a><span class="fu">sum</span> <span class="dt">Nil</span> <span class="ot">=</span> <span class="dv">0</span></span>
521+<span id="cb93-2"><a href="#cb93-2"></a><span class="fu">sum</span> (<span class="dt">Cons</span> x xs) <span class="ot">=</span> x <span class="op">+</span> <span class="fu">sum</span> xs</span></code></pre></div>
522+<div class="sourceCode" id="cb94"><pre class="sourceCode haskell fragment"><code class="sourceCode haskell"><span id="cb94-1"><a href="#cb94-1"></a><span class="fu">sum</span> nums</span>
523+<span id="cb94-2"><a href="#cb94-2"></a><span class="co">-- 6</span></span></code></pre></div>
524+</section>
525+<section class="slide level1">
526+
527+<div class="sourceCode" id="cb95"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb95-1"><a href="#cb95-1"></a><span class="fu">take</span><span class="ot"> ::</span> <span class="dt">Int</span> <span class="ot">-></span> <span class="dt">IntList</span> <span class="ot">-></span> <span class="dt">IntList</span></span></code></pre></div>
528+<div class="sourceCode" id="cb96"><pre class="sourceCode haskell fragment"><code class="sourceCode haskell"><span id="cb96-1"><a href="#cb96-1"></a><span class="fu">take</span> _ <span class="dt">Nil</span> <span class="ot">=</span> <span class="dt">Nil</span></span>
529+<span id="cb96-2"><a href="#cb96-2"></a><span class="fu">take</span> <span class="dv">0</span> _ <span class="ot">=</span> <span class="dt">Nil</span></span>
530+<span id="cb96-3"><a href="#cb96-3"></a><span class="fu">take</span> n (<span class="dt">Cons</span> x xs) <span class="ot">=</span> <span class="dt">Cons</span> x (<span class="fu">take</span> (n <span class="op">-</span> <span class="dv">1</span>) xs)</span></code></pre></div>
531+<div class="sourceCode" id="cb97"><pre class="sourceCode haskell fragment"><code class="sourceCode haskell"><span id="cb97-1"><a href="#cb97-1"></a><span class="ot">nums ::</span> <span class="dt">IntList</span></span>
532+<span id="cb97-2"><a href="#cb97-2"></a>nums <span class="ot">=</span> <span class="dv">1</span> <span class="ot">`Cons`</span> (<span class="dv">2</span> <span class="ot">`Cons`</span> (<span class="dv">3</span> <span class="ot">`Cons`</span> <span class="dt">Nil</span>))</span></code></pre></div>
533+<div class="sourceCode" id="cb98"><pre class="sourceCode haskell fragment"><code class="sourceCode haskell"><span id="cb98-1"><a href="#cb98-1"></a><span class="fu">take</span> <span class="dv">2</span> nums</span>
534+<span id="cb98-2"><a href="#cb98-2"></a><span class="co">-- Cons 1 (Cons 2 Nil)</span></span>
535+<span id="cb98-3"><a href="#cb98-3"></a><span class="fu">take</span> <span class="dv">1029</span> nums</span>
536+<span id="cb98-4"><a href="#cb98-4"></a><span class="co">-- Cons 1 (Cons 2 (Cons 3 Nil))</span></span>
537+<span id="cb98-5"><a href="#cb98-5"></a><span class="fu">take</span> <span class="dv">0</span> nums</span>
538+<span id="cb98-6"><a href="#cb98-6"></a><span class="co">-- Nil</span></span></code></pre></div>
539+</section>
540+<section class="slide level1">
541+
542+<div class="sourceCode" id="cb99"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb99-1"><a href="#cb99-1"></a><span class="fu">repeat</span><span class="ot"> ::</span> <span class="dt">Int</span> <span class="ot">-></span> <span class="dt">IntList</span></span></code></pre></div>
543+<div class="sourceCode" id="cb100"><pre class="sourceCode haskell fragment"><code class="sourceCode haskell"><span id="cb100-1"><a href="#cb100-1"></a><span class="fu">repeat</span> n <span class="ot">=</span> <span class="dt">Cons</span> n (<span class="fu">repeat</span> n)</span></code></pre></div>
544+<div class="sourceCode" id="cb101"><pre class="sourceCode haskell fragment"><code class="sourceCode haskell"><span id="cb101-1"><a href="#cb101-1"></a><span class="fu">repeat</span> <span class="dv">8</span></span>
545+<span id="cb101-2"><a href="#cb101-2"></a><span class="co">-- Cons 8 (Cons 8 (Cons 8 (Cons 8 (Cons 8 (Cons 8 (Cons 8 (Cons 8 (Cons 8 (Cons 8 (...</span></span></code></pre></div>
546+<div class="sourceCode" id="cb102"><pre class="sourceCode haskell fragment"><code class="sourceCode haskell"><span id="cb102-1"><a href="#cb102-1"></a>(<span class="fu">take</span> <span class="dv">3</span> <span class="op">.</span> <span class="fu">repeat</span>) <span class="dv">8</span></span>
547+<span id="cb102-2"><a href="#cb102-2"></a><span class="co">-- Cons 8 (Cons 8 (Cons 8 Nil))</span></span></code></pre></div>
548+<div class="sourceCode" id="cb103"><pre class="sourceCode haskell fragment"><code class="sourceCode haskell"><span id="cb103-1"><a href="#cb103-1"></a>(<span class="fu">sum</span> <span class="op">.</span> <span class="fu">take</span> <span class="dv">3</span> <span class="op">.</span> <span class="fu">repeat</span>) <span class="dv">8</span></span>
549+<span id="cb103-2"><a href="#cb103-2"></a><span class="co">-- 24</span></span></code></pre></div>
550+</section>
551+<section class="slide level1">
552+
553+<table width="100%">
554+<tr>
555+<td>
556+Наша самодеятельность
557+</td>
558+<td>
559+В стандартной библиотеке
560+</td>
561+</tr>
562+<tr class="fragment">
563+<td>
564+<div class="sourceCode" id="cb104"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb104-1"><a href="#cb104-1"></a> <span class="dt">IntList</span></span></code></pre></div>
565+</td>
566+<td>
567+<div class="sourceCode" id="cb105"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb105-1"><a href="#cb105-1"></a> [<span class="dt">Int</span>]</span></code></pre></div>
568+</td>
569+</tr>
570+<tr class="fragment">
571+<td>
572+<div class="sourceCode" id="cb106"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb106-1"><a href="#cb106-1"></a> <span class="dt">IntList</span></span></code></pre></div>
573+</td>
574+<td>
575+<div class="sourceCode" id="cb107"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb107-1"><a href="#cb107-1"></a> [<span class="dt">Int</span>]</span></code></pre></div>
576+</td>
577+</tr>
578+<tr class="fragment">
579+<td>
580+<div class="sourceCode" id="cb108"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb108-1"><a href="#cb108-1"></a> <span class="dt">Nil</span></span></code></pre></div>
581+</td>
582+<td>
583+<div class="sourceCode" id="cb109"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb109-1"><a href="#cb109-1"></a> []</span></code></pre></div>
584+</td>
585+</tr>
586+<tr class="fragment">
587+<td>
588+<div class="sourceCode" id="cb110"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb110-1"><a href="#cb110-1"></a> <span class="dt">Cons</span></span></code></pre></div>
589+</td>
590+<td>
591+<div class="sourceCode" id="cb111"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb111-1"><a href="#cb111-1"></a> <span class="op">:</span></span></code></pre></div>
592+</td>
593+</tr>
594+<tr class="fragment">
595+<td>
596+<div class="sourceCode" id="cb112"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb112-1"><a href="#cb112-1"></a> <span class="dt">Cons</span> <span class="dv">3</span> (<span class="dt">Cons</span> <span class="dv">4</span> <span class="dt">Nil</span>)</span></code></pre></div>
597+</td>
598+<td>
599+<div class="sourceCode" id="cb113"><pre class="sourceCode fragment haskell"><code class="sourceCode haskell"><span id="cb113-1"><a href="#cb113-1"></a> <span class="dv">3</span> <span class="op">:</span> <span class="dv">4</span> <span class="op">:</span> []</span></code></pre></div>
600+<div class="sourceCode" id="cb114"><pre class="sourceCode fragment haskell"><code class="sourceCode haskell"><span id="cb114-1"><a href="#cb114-1"></a> [<span class="dv">3</span>, <span class="dv">4</span>]</span></code></pre></div>
601+</td>
602+</tr>
603+</table>
604+</section>
605+<section class="slide level1">
606+
607+<p><code>repeat</code>, <code>sum</code> и <code>take</code> тоже есть в стандартной библиотеке.</p>
608+</section>
609+<section id="quicksort" class="slide level1">
610+<h1>QuickSort</h1>
611+</section>
612+<section class="slide level1">
613+
614+<div class="sourceCode" id="cb115"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb115-1"><a href="#cb115-1"></a><span class="ot">quicksort ::</span> [<span class="dt">Int</span>] <span class="ot">-></span> [<span class="dt">Int</span>]</span></code></pre></div>
615+<div class="sourceCode" id="cb116"><pre class="sourceCode haskell fragment"><code class="sourceCode haskell"><span id="cb116-1"><a href="#cb116-1"></a>quicksort (x<span class="op">:</span>xs) <span class="ot">=</span></span>
616+<span id="cb116-2"><a href="#cb116-2"></a> quicksort smaller <span class="op">++</span> [x] <span class="op">++</span> quicksort larger</span>
617+<span id="cb116-3"><a href="#cb116-3"></a> <span class="kw">where</span></span>
618+<span id="cb116-4"><a href="#cb116-4"></a> smaller <span class="ot">=</span> <span class="fu">filter</span> (<span class="op"><</span> x) xs</span>
619+<span id="cb116-5"><a href="#cb116-5"></a> larger <span class="ot">=</span> <span class="fu">filter</span> (<span class="op">>=</span> x) xs</span></code></pre></div>
620+</section>
621+<section class="slide level1">
622+
623+<div class="sourceCode" id="cb117"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb117-1"><a href="#cb117-1"></a><span class="fu">filter</span><span class="ot"> ::</span> (<span class="dt">Bool</span> <span class="ot">-></span> <span class="dt">Int</span>) <span class="ot">-></span> [<span class="dt">Int</span>] <span class="ot">-></span> [<span class="dt">Int</span>]</span></code></pre></div>
624+<div class="sourceCode" id="cb118"><pre class="sourceCode haskell fragment"><code class="sourceCode haskell"><span id="cb118-1"><a href="#cb118-1"></a><span class="fu">filter</span> f (x<span class="op">:</span>xs) <span class="ot">=</span></span>
625+<span id="cb118-2"><a href="#cb118-2"></a> <span class="kw">if</span> f x</span>
626+<span id="cb118-3"><a href="#cb118-3"></a> <span class="kw">then</span> <span class="fu">filter</span> f xs</span>
627+<span id="cb118-4"><a href="#cb118-4"></a> <span class="kw">else</span> x<span class="op">:</span>(<span class="fu">filter</span> f xs)</span></code></pre></div>
628+<div class="sourceCode" id="cb119"><pre class="sourceCode haskell fragment"><code class="sourceCode haskell"><span id="cb119-1"><a href="#cb119-1"></a><span class="fu">filter</span> _ [] <span class="ot">=</span> []</span>
629+<span id="cb119-2"><a href="#cb119-2"></a><span class="fu">filter</span> f (x<span class="op">:</span>xs) <span class="ot">=</span></span>
630+<span id="cb119-3"><a href="#cb119-3"></a> <span class="kw">if</span> f x</span>
631+<span id="cb119-4"><a href="#cb119-4"></a> <span class="kw">then</span> <span class="fu">filter</span> f xs</span>
632+<span id="cb119-5"><a href="#cb119-5"></a> <span class="kw">else</span> x<span class="op">:</span>(<span class="fu">filter</span> f xs)</span></code></pre></div>
633+</section>
634+<section class="slide level1">
635+
636+<div class="sourceCode" id="cb120"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb120-1"><a href="#cb120-1"></a><span class="ot">quicksort ::</span> [<span class="dt">Int</span>] <span class="ot">-></span> [<span class="dt">Int</span>]</span>
637+<span id="cb120-2"><a href="#cb120-2"></a>quicksort (x<span class="op">:</span>xs) <span class="ot">=</span></span>
638+<span id="cb120-3"><a href="#cb120-3"></a> quicksort smaller <span class="op">++</span> [x] <span class="op">++</span> quicksort larger</span>
639+<span id="cb120-4"><a href="#cb120-4"></a> <span class="kw">where</span></span>
640+<span id="cb120-5"><a href="#cb120-5"></a> smaller <span class="ot">=</span> <span class="fu">filter</span> (<span class="op"><</span> x) xs</span>
641+<span id="cb120-6"><a href="#cb120-6"></a> larger <span class="ot">=</span> <span class="fu">filter</span> (<span class="op">>=</span> x) xs</span>
642+<span id="cb120-7"><a href="#cb120-7"></a> <span class="fu">filter</span> _ [] <span class="ot">=</span> []</span>
643+<span id="cb120-8"><a href="#cb120-8"></a> <span class="fu">filter</span> f (x<span class="op">:</span>xs) <span class="ot">=</span></span>
644+<span id="cb120-9"><a href="#cb120-9"></a> <span class="kw">if</span> f x</span>
645+<span id="cb120-10"><a href="#cb120-10"></a> <span class="kw">then</span> <span class="fu">filter</span> f xs</span>
646+<span id="cb120-11"><a href="#cb120-11"></a> <span class="kw">else</span> x<span class="op">:</span>(<span class="fu">filter</span> f xs)</span></code></pre></div>
647+</section>
648+<section class="slide level1">
649+
650+<div class="sourceCode" id="cb121"><pre class="sourceCode haskell"><code class="sourceCode haskell"><span id="cb121-1"><a href="#cb121-1"></a><span class="ot">quicksort ::</span> [<span class="dt">Int</span>] <span class="ot">-></span> [<span class="dt">Int</span>]</span>
651+<span id="cb121-2"><a href="#cb121-2"></a>quicksort [] <span class="ot">=</span> []</span>
652+<span id="cb121-3"><a href="#cb121-3"></a>quicksort (x<span class="op">:</span>xs) <span class="ot">=</span></span>
653+<span id="cb121-4"><a href="#cb121-4"></a> quicksort smaller <span class="op">++</span> [x] <span class="op">++</span> quicksort larger</span>
654+<span id="cb121-5"><a href="#cb121-5"></a> <span class="kw">where</span></span>
655+<span id="cb121-6"><a href="#cb121-6"></a> smaller <span class="ot">=</span> <span class="fu">filter</span> (<span class="op"><</span> x) xs</span>
656+<span id="cb121-7"><a href="#cb121-7"></a> larger <span class="ot">=</span> <span class="fu">filter</span> (<span class="op">>=</span> x) xs</span>
657+<span id="cb121-8"><a href="#cb121-8"></a> <span class="fu">filter</span> _ [] <span class="ot">=</span> []</span>
658+<span id="cb121-9"><a href="#cb121-9"></a> <span class="fu">filter</span> f (x<span class="op">:</span>xs) <span class="ot">=</span></span>
659+<span id="cb121-10"><a href="#cb121-10"></a> <span class="kw">if</span> f x</span>
660+<span id="cb121-11"><a href="#cb121-11"></a> <span class="kw">then</span> <span class="fu">filter</span> f xs</span>
661+<span id="cb121-12"><a href="#cb121-12"></a> <span class="kw">else</span> x<span class="op">:</span>(<span class="fu">filter</span> f xs)</span></code></pre></div>
662+<div class="sourceCode" id="cb122"><pre class="sourceCode haskell fragment"><code class="sourceCode haskell"><span id="cb122-1"><a href="#cb122-1"></a>quicksort [<span class="dv">2</span>, <span class="dv">1</span>, <span class="dv">3</span>, <span class="dv">4</span>]</span>
663+<span id="cb122-2"><a href="#cb122-2"></a><span class="co">-- [1, 2, 3, 4]</span></span></code></pre></div>
664+</section>
665+<section class="slide level1">
666+
667+<p><code>filter</code> тоже есть в стандартной библиотеке.</p>
668+</section>
669+<section id="где-и-как-смотреть-стандартную-библиотеку" class="slide level1">
670+<h1>Где и как смотреть “стандартную библиотеку”</h1>
671+</section>
672+<section class="slide level1">
673+
674+<ol type="1">
675+<li class="fragment"><p><a href="https://hackage.haskell.org/package/base">Hackage</a></p>
676+<p>(Там вам нужен только пакет <code>base</code>. Ссылка ведет прямо на него.) Еще если там нажать <code>s</code>, то будет поиск.</p></li>
677+<li class="fragment"><p><a href="https://hoogle.haskell.org">Hoogle</a></p>
678+<p>Это поиск по типам. Например: <code>Int -> [Int] -> [Int]</code> (Тут вам опять же нужен только пакет <code>base</code>. Нужно чтобы справа было "package:base".) –></p></li>
679+</ol>
680+</section>
713681 </div>
714682 </div>
715683
716− <script src="./js/reveal.js"></script>
684+ <script src="reveal.js/js/reveal.js"></script>
717685
718686 <script>
719− // More info about config & dependencies:
720− // - https://github.com/hakimel/reveal.js#configuration
721− // - https://github.com/hakimel/reveal.js#dependencies
722− Reveal.initialize({
723−
724− // Displaнес presentation control arrows
725− controls: true,
726−
727− // Help the user learn the controls by providing hints, for example by
728− // bouncing the down arrow when they first encounter a vertical slide
729− controlsTutorial: true,
730−
731− // Determines where controls appear, "edges" or "bottom-right"
732− controlsLayout: 'bottom-right',
733−
734− // Visibility rule for backwards navigation arrows; "faded", "hidden"
735− // or "visible"
736− controlsBackArrows: 'faded',
737−
738− // Display a presentation progress bar
739− progress: true,
740−
741− // Display the page number of the current slide
742− slideNumber: false,
743−
744− // Add the current slide number to the URL hash so that reloading the
745− // page/copying the URL will return you to the same slide
746− hash: true,
747−
748− // Push each slide change to the browser history. Implies `hash: true`
749− history: false,
750−
751− // Enable keyboard shortcuts for navigation
752− keyboard: true,
753−
754− // Enable the slide overview mode
755− overview: true,
756−
757− // Vertical centering of slides
758− center: true,
759−
760− // Enables touch navigation on devices with touch input
761− touch: true,
762−
763− // Loop the presentation
764− loop: false,
765−
766− // Change the presentation direction to be RTL
767− rtl: false,
768−
769− // See https://github.com/hakimel/reveal.js/#navigation-mode
770− navigationMode: 'linear',
771−
772− // Randomizes the order of slides each time the presentation loads
773− shuffle: false,
774−
775− // Turns fragments on and off globally
776− fragments: true,
777−
778− // Flags whether to include the current fragment in the URL,
779− // so that reloading brings you to the same fragment position
780− fragmentInURL: true,
781−
782− // Flags if the presentation is running in an embedded mode,
783− // i.e. contained within a limited portion of the screen
784− embedded: false,
785−
786− // Flags if we should show a help overlay when the questionmark
787− // key is pressed
788− help: true,
789−
790− // Flags if speaker notes should be visible to all viewers
791− showNotes: false,
792−
793− // Global override for autoplaying embedded media (video/audio/iframe)
794− // - null: Media will only autoplay if data-autoplay is present
795− // - true: All media will autoplay, regardless of individual setting
796− // - false: No media will autoplay, regardless of individual setting
797− autoPlayMedia: null,
798−
799− // Global override for preloading lazy-loaded iframes
800− // - null: Iframes with data-src AND data-preload will be loaded when within
801− // the viewDistance, iframes with only data-src will be loaded when visible
802− // - true: All iframes with data-src will be loaded when within the viewDistance
803− // - false: All iframes with data-src will be loaded only when visible
804− preloadIframes: null,
805−
806− // Number of milliseconds between automatically proceeding to the
807− // next slide, disabled when set to 0, this value can be overwritten
808− // by using a data-autoslide attribute on your slides
809− autoSlide: 0,
810−
811− // Stop auto-sliding after user input
812− autoSlideStoppable: true,
813−
814− // Use this method for navigation when auto-sliding
815− autoSlideMethod: Reveal.navigateNext,
816−
817− // Specify the average time in seconds that you think you will spend
818− // presenting each slide. This is used to show a pacing timer in the
819− // speaker view
820− defaultTiming: 120,
821−
822− // Enable slide navigation via mouse wheel
823− mouseWheel: false,
824−
825− // Hide cursor if inactive
826− hideInactiveCursor: true,
827−
828− // Time before the cursor is hidden (in ms)
829− hideCursorTime: 5000,
830−
831− // Hides the address bar on mobile devices
832− hideAddressBar: true,
833−
834− // Opens links in an iframe preview overlay
835− // Add `data-preview-link` and `data-preview-link="false"` to customise each link
836− // individually
837− previewLinks: false,
838−
839− // Transition style
840− transition: 'slide', // none/fade/slide/convex/concave/zoom
841−
842− // Transition speed
843− transitionSpeed: 'default', // default/fast/slow
844−
845− // Transition style for full page slide backgrounds
846− backgroundTransition: 'fade', // none/fade/slide/convex/concave/zoom
847−
848− // Number of slides away from the current that are visible
849− viewDistance: 3,
850−
851− // Parallax background image
852− parallaxBackgroundImage: '', // e.g. "'https://s3.amazonaws.com/hakim-static/reveal-js/reveal-parallax-1.jpg'"
853−
854− // Parallax background size
855− parallaxBackgroundSize: '', // CSS syntax, e.g. "2100px 900px"
856−
857− // Number of pixels to move the parallax background per slide
858− // - Calculated automatically unless specified
859− // - Set to 0 to disable movement along an axis
860− parallaxBackgroundHorizontal: null,
861− parallaxBackgroundVertical: null,
862−
863− // The display mode that will be used to show slides
864− display: 'block',
865−
866− pdfSeparateFragments: false,
867−
868− defaultTiming: null,
869−
870− markdown: {
871− smartypants: true
872− },
873−
874−
875− dependencies: [
876− { src: './plugin/markdown/marked.js' },
877− { src: './plugin/markdown/markdown.js' },
878− { src: './plugin/zoom-js/zoom.js', async: true },
879− { src: './plugin/notes/notes.js', async: true },
880− { src: './plugin/highlight/highlight.js', async: true }
881− ]
882−
883− });
884− </script>
885−</body>
886687
688+ // Full list of configuration options available at:
689+ // https://github.com/hakimel/reveal.js#configuration
690+ Reveal.initialize({
691+ // Push each slide change to the browser history
692+ history: true,
693+
694+ // Optional reveal.js plugins
695+ dependencies: [
696+ { src: 'reveal.js/lib/js/classList.js', condition: function() { return !document.body.classList; } },
697+ { src: 'reveal.js/plugin/zoom-js/zoom.js', async: true },
698+ { src: 'reveal.js/plugin/notes/notes.js', async: true }
699+ ]
700+ });
701+ </script>
702+ </body>
887703</html>