<p>Функциональное программирование это не про использование map filter reduce. Функциональное программирование это вообще ортогонально к ооп. ИМХО проблема с ООП – наследование (которое тоже ортогонально к ООП) – нет разграничения между абстракцией и реализацией. и вообще обзывание это функциональным программированием – не совсем правильно. то, что мы сейчас будем пытаться сделать – сделать код более переиспользуемым. сделать наши данные максимально тупыми => переиспользуемыми. пытаться комбинировать слишком умные куски – не получится – слишком сложно. мы хотим сделать простые куски, которые просто комбинировать и еще чтобы компилятор проверял эти наши комбинации на валидность.</p>
<p><code>Int -> Bool</code> (функция) – ровно такие же данные как и <code>Int</code>. Их также можно складывать в структуры, передавать как аргументы и т. п.</p>
<divclass="sourceCode"id="cb2"><preclass="sourceCode haskell"><codeclass="sourceCode haskell"><spanid="cb2-1"><ahref="#cb2-1"></a><spanclass="ot"> x ::</span><spanclass="dt">Int</span></span></code></pre></div>
<divclass="sourceCode"id="cb4"><preclass="sourceCode haskell"><codeclass="sourceCode haskell"><spanid="cb4-1"><ahref="#cb4-1"></a><spanclass="ot"> f ::</span><spanclass="dt">Int</span><spanclass="ot">-></span><spanclass="dt">Int</span></span></code></pre></div>
</td>
</tr>
<trclass="fragment">
<td>
<divclass="sourceCode"id="cb5"><preclass="sourceCode java"><codeclass="sourceCode java"><spanid="cb5-1"><ahref="#cb5-1"></a><spanclass="dt">static</span><T> T <spanclass="fu">f</span>(T x)</span></code></pre></div>
</td>
<td>
<divclass="sourceCode"id="cb6"><preclass="sourceCode haskell"><codeclass="sourceCode haskell"><spanid="cb6-1"><ahref="#cb6-1"></a><spanclass="ot"> f ::</span> a <spanclass="ot">-></span> a</span></code></pre></div>
</td>
</tr>
</table>
</section>
<sectionclass="slide level1">
<tablewidth="100%">
<tr>
<td>
<divclass="sourceCode"id="cb7"><preclass="sourceCode java"><codeclass="sourceCode java"><spanid="cb7-1"><ahref="#cb7-1"></a><spanclass="dt">static</span><T> T <spanclass="fu">f</span>(T x)</span></code></pre></div>
</td>
<td>
<divclass="sourceCode"id="cb8"><preclass="sourceCode haskell"><codeclass="sourceCode haskell"><spanid="cb8-1"><ahref="#cb8-1"></a><spanclass="ot"> f ::</span> a <spanclass="ot">-></span> a</span></code></pre></div>
<divclass="sourceCode"id="cb10"><preclass="sourceCode haskell"><codeclass="sourceCode haskell"><spanid="cb10-1"><ahref="#cb10-1"></a> f x</span></code></pre></div>
<divclass="sourceCode"id="cb12"><preclass="sourceCode fragment haskell"><codeclass="sourceCode haskell"><spanid="cb12-1"><ahref="#cb12-1"></a> f x y</span></code></pre></div>
<divclass="sourceCode"id="cb13"><preclass="sourceCode fragment haskell"><codeclass="sourceCode haskell"><spanid="cb13-1"><ahref="#cb13-1"></a> f x y <spanclass="ot">=</span> (f x) y</span></code></pre></div>
</td>
</td>
</tr>
</table>
<asideclass="notes">
<p>Left-associative Currying</p>
</aside>
</section>
<sectionclass="slide level1">
<tablewidth="100%">
<tr>
<td>
<divclass="sourceCode"id="cb14"><preclass="sourceCode java"><codeclass="sourceCode java"><spanid="cb14-1"><ahref="#cb14-1"></a><spanclass="dt">static</span><T> T <spanclass="fu">f</span>(T x)</span>
<spanid="cb14-2"><ahref="#cb14-2"></a><spanclass="dt">static</span><T> T <spanclass="fu">g</span>(T x)</span></code></pre></div>
</td>
<td>
<divclass="sourceCode"id="cb15"><preclass="sourceCode haskell"><codeclass="sourceCode haskell"><spanid="cb15-1"><ahref="#cb15-1"></a><spanclass="ot"> f ::</span> a <spanclass="ot">-></span> a</span>
<spanid="cb15-2"><ahref="#cb15-2"></a><spanclass="ot"> g ::</span> a <spanclass="ot">-></span> a</span></code></pre></div>
<divclass="sourceCode"id="cb17"><preclass="sourceCode haskell"><codeclass="sourceCode haskell"><spanid="cb17-1"><ahref="#cb17-1"></a> f (g x)</span>
<spanid="cb17-2"><ahref="#cb17-2"></a> g (f x)</span></code></pre></div>
</td>
</tr>
</table>
</section>
<sectionid="композиция"class="slide level1">
<h1>Композиция</h1>
</section>
<sectionclass="slide level1">
<divclass="sourceCode"id="cb18"><preclass="sourceCode haskell"><codeclass="sourceCode haskell"><spanid="cb18-1"><ahref="#cb18-1"></a><spanclass="ot">f ::</span> a <spanclass="ot">-></span> a</span>
<spanid="cb18-2"><ahref="#cb18-2"></a><spanclass="ot">g ::</span> a <spanclass="ot">-></span> a</span></code></pre></div>
<divclass="sourceCode"id="cb19"><preclass="sourceCode fragment haskell"><codeclass="sourceCode haskell"><spanid="cb19-1"><ahref="#cb19-1"></a>f (g x)</span></code></pre></div>
<divclass="sourceCode"id="cb20"><preclass="sourceCode fragment haskell"><codeclass="sourceCode haskell"><spanid="cb20-1"><ahref="#cb20-1"></a>(f <spanclass="op">.</span> g) x <spanclass="op">==</span> f (g x)</span></code></pre></div>
<divclass="sourceCode"id="cb21"><preclass="sourceCode fragment haskell"><codeclass="sourceCode haskell"><spanid="cb21-1"><ahref="#cb21-1"></a>h <spanclass="ot">=</span> f <spanclass="op">.</span> g</span>
<spanid="cb21-2"><ahref="#cb21-2"></a>h x <spanclass="op">==</span> f (g x)</span></code></pre></div>
</section>
<sectionclass="slide level1">
<divclass="sourceCode"id="cb22"><preclass="sourceCode haskell"><codeclass="sourceCode haskell"><spanid="cb22-1"><ahref="#cb22-1"></a><spanclass="ot">f ::</span> a <spanclass="ot">-></span> a</span>
<spanid="cb22-2"><ahref="#cb22-2"></a><spanclass="ot">g ::</span> a <spanclass="ot">-></span> a</span></code></pre></div>
<divclass="sourceCode"id="cb23"><preclass="sourceCode haskell"><codeclass="sourceCode haskell"><spanid="cb23-1"><ahref="#cb23-1"></a><spanclass="ot">h ::</span> a <spanclass="ot">-></span> a</span>
<spanid="cb23-2"><ahref="#cb23-2"></a>h <spanclass="ot">=</span> f <spanclass="op">.</span> g</span></code></pre></div>
<p>моноид –у тебя есть две штуки одного типа и ты можешь получить еще одну штуку такого же типа. Это очень простой способ рождения сложности из простоты причем тип h выводится из определения. Нам его указывать не надо. если у нас изначальные маленькие кусочки хорошо описаны, то порожденные большие кусочки будут автоматически хорошо описанными.</p>
<divclass="sourceCode"id="cb24"><preclass="sourceCode fragment haskell"><codeclass="sourceCode haskell"><spanid="cb24-1"><ahref="#cb24-1"></a><spanclass="ot">(.) ::</span> (a <spanclass="ot">-></span> a) <spanclass="ot">-></span> (a <spanclass="ot">-></span> a) <spanclass="ot">-></span> (a <spanclass="ot">-></span> a)</span></code></pre></div>
<divclass="sourceCode"id="cb25"><preclass="sourceCode fragment haskell"><codeclass="sourceCode haskell"><spanid="cb25-1"><ahref="#cb25-1"></a><spanclass="fu">id</span><spanclass="ot"> ::</span> a <spanclass="ot">-></span> a</span>
<spanid="cb25-2"><ahref="#cb25-2"></a><spanclass="fu">id</span> x <spanclass="ot">=</span> x</span></code></pre></div>
<p>Все что функция может сделать – посмотреть на свои аргументы это вернуть значение.</p>
<asideclass="notes">
<p>Нельзя просто произвольно распечатать строку в консоль, нельзя просто произвольно отправить запрос на бд, нельзя просто произвольно изменить глобальную переменную.</p>
<h5id="любую-константу-можно-заменить-на-само-значение">(Любую константу можно заменить на само значение)</h5>
<divclass="sourceCode"id="cb26"><preclass="sourceCode java fragment"><codeclass="sourceCode java"><spanid="cb26-1"><ahref="#cb26-1"></a><spanclass="dt">int</span> x = <spanclass="dv">8</span>;</span>
<spanid="cb26-2"><ahref="#cb26-2"></a><spanclass="dt">int</span> y = x++;</span>
<spanid="cb26-3"><ahref="#cb26-3"></a><spanclass="bu">System</span>.<spanclass="fu">out</span>.<spanclass="fu">println</span>(y + <spanclass="st">" might be the same as "</span> + y);</span></code></pre></div>
<divclass="sourceCode"id="cb27"><preclass="sourceCode java fragment"><codeclass="sourceCode java"><spanid="cb27-1"><ahref="#cb27-1"></a><spanclass="dt">int</span> x = <spanclass="dv">8</span>;</span>
<spanid="cb27-2"><ahref="#cb27-2"></a><spanclass="bu">System</span>.<spanclass="fu">out</span>.<spanclass="fu">println</span>(x++ + <spanclass="st">" might be the same as "</span> + x++);</span></code></pre></div>
<asideclass="notes">
<p>Сильно упрощает рефакторинг и понимание кода.</p>
</aside>
</section>
<sectionclass="slide level1">
<h3id="нет-переменных-циклов-и-условных-переходов">Нет переменных, циклов и условных переходов</h3>
<p><spanclass="fragment">Зато есть константы и нормальная рекурсия (А переходов вообще нет)</span></p>
<p>функции объявляются в несколькро строк. Первая – обьявленик типа функции, а последующие – реализация. В общем случае тип можно не указывать, но указывать тип у высказыванй на самом верхнем уровне (не вложенные) считается хорошим тоном и улучшает выведение типов и ошибки компиляции. У функции может быть несколько реализаций: какая из них вызовется зависит от значений передаваемых аргументов. матчинг произхводится сверху вниз. если в аргемантах написано слово с маленькой буквы, то значение аргумента биндится на эту константу.</p>
<spanid="cb37-2"><ahref="#cb37-2"></a>greetPerson p <spanclass="ot">=</span><spanclass="st">"Hello, "</span><spanclass="op">++</span> getName p</span></code></pre></div>
<divclass="sourceCode"id="cb38"><preclass="sourceCode fragment haskell"><codeclass="sourceCode haskell"><spanid="cb38-1"><ahref="#cb38-1"></a><spanclass="ot">greetPerson ::</span><spanclass="dt">PersonType</span><spanclass="ot">-></span><spanclass="dt">String</span></span>
<spanid="cb38-2"><ahref="#cb38-2"></a>greetPerson p <spanclass="ot">=</span><spanclass="st">"Hello, "</span><spanclass="op">++</span> name</span>
<spanid="cb38-4"><ahref="#cb38-4"></a> name <spanclass="ot">=</span> getName p</span></code></pre></div>
<divclass="sourceCode"id="cb39"><preclass="sourceCode fragment haskell"><codeclass="sourceCode haskell"><spanid="cb39-1"><ahref="#cb39-1"></a><spanclass="ot">greetPerson ::</span><spanclass="dt">PersonType</span><spanclass="ot">-></span><spanclass="dt">String</span></span>
<spanid="cb39-2"><ahref="#cb39-2"></a>greetPerson p <spanclass="ot">=</span><spanclass="st">"Hello, "</span><spanclass="op">++</span> name</span>
<spanid="cb40-4"><ahref="#cb40-4"></a>getName (<spanclass="dt">Person</span> name _) <spanclass="ot">=</span> name</span></code></pre></div>
<divclass="sourceCode"id="cb41"><preclass="sourceCode fragment haskell"><codeclass="sourceCode haskell"><spanid="cb41-1"><ahref="#cb41-1"></a><spanclass="ot">greetName ::</span><spanclass="dt">String</span><spanclass="ot">-></span><spanclass="dt">String</span></span>
<spanid="cb41-2"><ahref="#cb41-2"></a>greetName name <spanclass="ot">=</span><spanclass="st">"Hello, "</span><spanclass="op">++</span> name</span></code></pre></div>
<divclass="sourceCode"id="cb42"><preclass="sourceCode fragment haskell"><codeclass="sourceCode haskell"><spanid="cb42-1"><ahref="#cb42-1"></a><spanclass="ot">greetPerson ::</span><spanclass="dt">PersonType</span><spanclass="ot">-></span><spanclass="dt">String</span></span>
<spanid="cb42-2"><ahref="#cb42-2"></a>greetPerson p <spanclass="ot">=</span> greetName (getName p)</span></code></pre></div>
<divclass="sourceCode"id="cb43"><preclass="sourceCode fragment haskell"><codeclass="sourceCode haskell"><spanid="cb43-1"><ahref="#cb43-1"></a><spanclass="ot">greetPerson ::</span><spanclass="dt">PersonType</span><spanclass="ot">-></span><spanclass="dt">String</span></span>
<divclass="sourceCode"id="cb44"><preclass="sourceCode fragment haskell"><codeclass="sourceCode haskell"><spanid="cb44-1"><ahref="#cb44-1"></a>greetPerson petya</span>
<p>Функции нескольких аргументов – странный синтаксис – потом расскажу. А пока используем тюпли!</p>
</aside>
<divclass="sourceCode"id="cb46"><preclass="sourceCode fragment haskell"><codeclass="sourceCode haskell"><spanid="cb46-1"><ahref="#cb46-1"></a><spanclass="kw">data</span><spanclass="dt">Bool</span><spanclass="ot">=</span><spanclass="dt">False</span><spanclass="op">|</span><spanclass="dt">True</span></span></code></pre></div>
<divclass="sourceCode"id="cb47"><preclass="sourceCode fragment haskell"><codeclass="sourceCode haskell"><spanid="cb47-1"><ahref="#cb47-1"></a><spanclass="ot">x ::</span><spanclass="dt">Bool</span></span>
<divclass="sourceCode"id="cb48"><preclass="sourceCode fragment haskell"><codeclass="sourceCode haskell"><spanid="cb48-1"><ahref="#cb48-1"></a><spanclass="ot">ifThenElse ::</span> (<spanclass="dt">Bool</span>, a, a) <spanclass="ot">-></span> a</span></code></pre></div>
<divclass="sourceCode"id="cb49"><preclass="sourceCode fragment haskell"><codeclass="sourceCode haskell"><spanid="cb49-1"><ahref="#cb49-1"></a>ifThenElse (<spanclass="dt">True</span>, a, _) <spanclass="ot">=</span> a</span>
<spanid="cb49-2"><ahref="#cb49-2"></a>ifThenElse (<spanclass="dt">False</span>, _, b) <spanclass="ot">=</span> b</span></code></pre></div>
<divclass="sourceCode"id="cb50"><preclass="sourceCode fragment haskell"><codeclass="sourceCode haskell"><spanid="cb50-1"><ahref="#cb50-1"></a>ifThenElse (<spanclass="dt">True</span>, <spanclass="st">"Hello"</span>, <spanclass="st">"World"</span>)</span>
<divclass="sourceCode"id="cb53"><preclass="sourceCode fragment haskell"><codeclass="sourceCode haskell"><spanid="cb53-1"><ahref="#cb53-1"></a><spanclass="kw">data</span><spanclass="dt">Shape</span><spanclass="ot">=</span></span>
<divclass="sourceCode"id="cb54"><preclass="sourceCode fragment haskell"><codeclass="sourceCode haskell"><spanid="cb54-1"><ahref="#cb54-1"></a><spanclass="ot">surface ::</span><spanclass="dt">Shape</span><spanclass="ot">-></span><spanclass="dt">Double</span></span></code></pre></div>
<divclass="sourceCode"id="cb55"><preclass="sourceCode fragment haskell"><codeclass="sourceCode haskell"><spanid="cb55-1"><ahref="#cb55-1"></a>surface (<spanclass="dt">CircleShape</span> (<spanclass="dt">Circle</span> _ _ r)) <spanclass="ot">=</span></span>
<spanid="cb55-2"><ahref="#cb55-2"></a><spanclass="fu">pi</span><spanclass="op">*</span> r <spanclass="op">^</span><spanclass="dv">2</span></span></code></pre></div>
<divclass="sourceCode"id="cb60"><preclass="sourceCode haskell fragment"><codeclass="sourceCode haskell"><spanid="cb60-1"><ahref="#cb60-1"></a>add8 x <spanclass="ot">=</span> x <spanclass="op">+</span><spanclass="dv">8</span></span></code></pre></div>
<divclass="sourceCode"id="cb61"><preclass="sourceCode haskell fragment"><codeclass="sourceCode haskell"><spanid="cb61-1"><ahref="#cb61-1"></a>add8 <spanclass="ot">=</span> \x <spanclass="ot">-></span> x <spanclass="op">+</span><spanclass="dv">8</span></span></code></pre></div>
<divclass="sourceCode"id="cb64"><preclass="sourceCode haskell fragment"><codeclass="sourceCode haskell"><spanid="cb64-1"><ahref="#cb64-1"></a>foo (\x <spanclass="ot">-></span> x <spanclass="op">+</span><spanclass="dv">8</span>)</span></code></pre></div>
</section>
<sectionclass="slide level1">
<h3id="давайте-придумаем-синтаксис-для-функции-нескольких-аргументов">Давайте придумаем синтаксис для функции нескольких аргументов!</h3>
</section>
<sectionclass="slide level1">
<divclass="sourceCode"id="cb65"><preclass="sourceCode haskell"><codeclass="sourceCode haskell"><spanid="cb65-1"><ahref="#cb65-1"></a>x,<spanclass="ot"> y ::</span><spanclass="dt">Int</span></span>
<divclass="sourceCode"id="cb73"><preclass="sourceCode haskell fragment"><codeclass="sourceCode haskell"><spanid="cb73-1"><ahref="#cb73-1"></a>add a b <spanclass="ot">=</span> a <spanclass="op">+</span> b</span></code></pre></div>
<divclass="sourceCode"id="cb74"><preclass="sourceCode haskell fragment"><codeclass="sourceCode haskell"><spanid="cb74-1"><ahref="#cb74-1"></a>add <spanclass="ot">=</span> \a b <spanclass="ot">-></span> a <spanclass="op">+</span> b</span></code></pre></div>
<p><spanclass="fragment">Оператор (например <code>+</code>) – функция, название которой не содержит буквы и цифры.</span></p>
<divclass="sourceCode"id="cb80"><preclass="sourceCode haskell fragment"><codeclass="sourceCode haskell"><spanid="cb80-1"><ahref="#cb80-1"></a>x <spanclass="op">+&+</span> y <spanclass="ot">=</span> x <spanclass="op">+</span> y</span></code></pre></div>
<spanid="cb93-2"><ahref="#cb93-2"></a><spanclass="fu">sum</span> (<spanclass="dt">Cons</span> x xs) <spanclass="ot">=</span> x <spanclass="op">+</span><spanclass="fu">sum</span> xs</span></code></pre></div>
<spanid="cb96-3"><ahref="#cb96-3"></a><spanclass="fu">take</span> n (<spanclass="dt">Cons</span> x xs) <spanclass="ot">=</span><spanclass="dt">Cons</span> x (<spanclass="fu">take</span> (n <spanclass="op">-</span><spanclass="dv">1</span>) xs)</span></code></pre></div>
<divclass="sourceCode"id="cb100"><preclass="sourceCode haskell fragment"><codeclass="sourceCode haskell"><spanid="cb100-1"><ahref="#cb100-1"></a><spanclass="fu">repeat</span> n <spanclass="ot">=</span><spanclass="dt">Cons</span> n (<spanclass="fu">repeat</span> n)</span></code></pre></div>
<divclass="sourceCode"id="cb113"><preclass="sourceCode fragment haskell"><codeclass="sourceCode haskell"><spanid="cb113-1"><ahref="#cb113-1"></a><spanclass="dv">3</span><spanclass="op">:</span><spanclass="dv">4</span><spanclass="op">:</span> []</span></code></pre></div>
<divclass="sourceCode"id="cb114"><preclass="sourceCode fragment haskell"><codeclass="sourceCode haskell"><spanid="cb114-1"><ahref="#cb114-1"></a> [<spanclass="dv">3</span>, <spanclass="dv">4</span>]</span></code></pre></div>
</td>
</tr>
</table>
</section>
<sectionclass="slide level1">
<p><code>repeat</code>, <code>sum</code> и <code>take</code> тоже есть в стандартной библиотеке.</p>
<divclass="sourceCode"id="cb118"><preclass="sourceCode haskell fragment"><codeclass="sourceCode haskell"><spanid="cb118-1"><ahref="#cb118-1"></a><spanclass="fu">filter</span> f (x<spanclass="op">:</span>xs) <spanclass="ot">=</span></span>
<spanid="cb118-2"><ahref="#cb118-2"></a><spanclass="kw">if</span> f x</span>
<spanid="cb118-3"><ahref="#cb118-3"></a><spanclass="kw">then</span><spanclass="fu">filter</span> f xs</span>
<spanid="cb118-4"><ahref="#cb118-4"></a><spanclass="kw">else</span> x<spanclass="op">:</span>(<spanclass="fu">filter</span> f xs)</span></code></pre></div>
<spanid="cb119-2"><ahref="#cb119-2"></a><spanclass="fu">filter</span> f (x<spanclass="op">:</span>xs) <spanclass="ot">=</span></span>
<spanid="cb119-3"><ahref="#cb119-3"></a><spanclass="kw">if</span> f x</span>
<spanid="cb119-4"><ahref="#cb119-4"></a><spanclass="kw">then</span><spanclass="fu">filter</span> f xs</span>
<spanid="cb119-5"><ahref="#cb119-5"></a><spanclass="kw">else</span> x<spanclass="op">:</span>(<spanclass="fu">filter</span> f xs)</span></code></pre></div>
<spanid="cb120-8"><ahref="#cb120-8"></a><spanclass="fu">filter</span> f (x<spanclass="op">:</span>xs) <spanclass="ot">=</span></span>
<spanid="cb120-9"><ahref="#cb120-9"></a><spanclass="kw">if</span> f x</span>
<spanid="cb120-10"><ahref="#cb120-10"></a><spanclass="kw">then</span><spanclass="fu">filter</span> f xs</span>
<spanid="cb120-11"><ahref="#cb120-11"></a><spanclass="kw">else</span> x<spanclass="op">:</span>(<spanclass="fu">filter</span> f xs)</span></code></pre></div>
<spanid="cb121-9"><ahref="#cb121-9"></a><spanclass="fu">filter</span> f (x<spanclass="op">:</span>xs) <spanclass="ot">=</span></span>
<spanid="cb121-10"><ahref="#cb121-10"></a><spanclass="kw">if</span> f x</span>
<spanid="cb121-11"><ahref="#cb121-11"></a><spanclass="kw">then</span><spanclass="fu">filter</span> f xs</span>
<spanid="cb121-12"><ahref="#cb121-12"></a><spanclass="kw">else</span> x<spanclass="op">:</span>(<spanclass="fu">filter</span> f xs)</span></code></pre></div>
<p>Мы научиоись делать список интов. А что если мы хотим сделать просто список. Чего-нибудь.</p>
</aside>
<divclass="sourceCode"id="cb124"><pre class="sourceCode haskell fragment"><codeclass="sourceCode haskell"><spanid="cb124-1"><ahref="#cb124-1"></a><spanclass="kw">data</span><spanclass="dt">List</span> a <spanclass="ot">=</span><spanclass="dt">Cons</span> a (<spanclass="dt">List</span> a) <spanclass="op">|</span><spanclass="dt">Nil</span></span></code></pre></div>
<divclass="sourceCode"id="cb126"><preclass="sourceCode haskell fragment"><codeclass="sourceCode haskell"><spanid="cb126-1"><ahref="#cb126-1"></a><spanclass="co">-- Типы как всегда можно не писать</span></span>
<divclass="sourceCode"id="cb130"><preclass="sourceCode haskell fragment"><codeclass="sourceCode haskell"><spanid="cb130-1"><ahref="#cb130-1"></a><spanclass="kw">data</span><spanclass="dt">List</span> a <spanclass="ot">=</span><spanclass="dt">Cons</span> a (<spanclass="dt">List</span> a) <spanclass="op">|</span><spanclass="dt">Nil</span></span></code></pre></div>
<p><spanclass="fragment"><code>a</code> должен всегда быть <code>a</code>.</span></p>
<spanid="cb131-4"><ahref="#cb131-4"></a><spanclass="fu">take</span> n (<spanclass="dt">Cons</span> x xs) <spanclass="ot">=</span><spanclass="dt">Cons</span> x (<spanclass="fu">take</span> (n <spanclass="op">-</span><spanclass="dv">1</span>) xs)</span></code></pre></div>
<divclass="sourceCode"id="cb132"><preclass="sourceCode haskell fragment"><codeclass="sourceCode haskell"><spanid="cb132-1"><ahref="#cb132-1"></a><spanclass="fu">take</span><spanclass="ot"> ::</span><spanclass="dt">Int</span><spanclass="ot">-></span><spanclass="dt">List</span> a <spanclass="ot">-></span><spanclass="dt">List</span> a</span>
<spanid="cb132-4"><ahref="#cb132-4"></a><spanclass="fu">take</span> n (<spanclass="dt">Cons</span> x xs) <spanclass="ot">=</span><spanclass="dt">Cons</span> x (<spanclass="fu">take</span> (n <spanclass="op">-</span><spanclass="dv">1</span>) xs)</span></code></pre></div>
<p>Это поиск по типам. Например: <code>Int -> [Int] -> [Int]</code> (Тут вам опять же нужен только пакет <code>base</code>. Нужно чтобы справа было "package:base".)</p></li>
</ol>
</section>
</div>
</div>
<scriptsrc="reveal.js/js/reveal.js"></script>
<script>
// Full list of configuration options available at: