Funkcionální programování v Pythonu s využitím knihovny Toolz (3. část)

Obsah

1. Funkcionální programování v Pythonu s využitím knihovny Toolz (3. část)

2. Curryfikace (currying)

3. Operace curry zapisovaná formou konstrukce objektu

4. Curryfikace funkce bez parametrů a funkce s jedním parametrem

5. Operace curry zapisovaná formou dekorátoru

6. Curryfikace funkcí definovaných přímo v knihovně Toolz

7. Import již curryfikovaných funkcí z knihovny Toolz

8. Curryfikované varianty standardních funkcí map, filter a reduce

9. Kompozice funkcí

10. Operace compose

11. Operace compose_left

12. Vytvoření kolony (pipe) funkcí pipe

13. Obsah závěrečného článku o knihovně Toolz

14. Repositář s demonstračními příklady

15. Odkazy na Internetu

1. Funkcionální programování v Pythonu s využitím knihovny Toolz (3. část)

V pořadí již třetím článku o funkcionální knihovně Toolz opustíme funkce, které jsou určené pro zpracování sekvencí (ať již sekvencí konečných nebo nekonečných). Namísto toho se zaměříme na mnohem zajímavější oblast, konkrétně na problematiku transformaci funkcí, na takzvaný currying (curifikaci), taktéž na částečné vyhodnocení funkcí atd. Jedná se o programovací techniky, které jsme mohli vidět (i když v poněkud odlišné podobě) i v knihovně funcy. Knihovna Toolz ovšem nabízí ucelenější a dobře propojené API k těmto funkcionálním technikám. Navíc je některé dále popsané operace možné zapsat formou dekorátoru, což je ve výsledku velmi čitelné řešení (jak ostatně uvidíme v demonstračních příkladech). A nesmíme zapomenout ani na to, že prakticky všechny funkce z knihovny Toolz jsou dostupné již ve své curryfikované podobě (pouze je nutné je naimportovat z jiného balíčku, konkrétně z balíčku toolz.curried, jak to ostatně uvidíme v demonstračních příkladech).

2. Curryfikace (currying)

S curryfikací jsme se již ve stručnosti seznámili v předchozích článcích, takže si v této kapitole jen shrneme základní pojmy. Pod termínem curryfikace (currying) se v teorii programovacích jazyků (ovšem i obecně v matematice) označuje proces, jímž se transformuje funkce, která má více než jeden parametr, do řady vložených funkcí, přičemž každá z nich má jen jediný parametr (jen na okraj – čistou funkci bez parametrů lze nahradit konstantou, takže do této skupiny nespadá). Curryfikaci si můžeme představit jako postupnou transformaci funkce s n parametry na jinak zkonstruovanou funkci s n-1 parametry atd. až rekurzivně dojdeme k funkci s jediným parametrem:

x = f(a,b,c) →
    h = g(a)
    i = h(b)
    x = i(c)

Nebo lze prakticky totéž zapsat na jediném programovém řádku:

x = f(a,b,c) → g(a)(b)(c)

To zní sice, alespoň na první pohled, poměrně složitě, ale v praxi je (například v programovacím jazyku ML, ale i v některých dalších funkcionálních programovacích jazycích) proces curryfikace realizován z pohledu programátora automaticky již samotným zápisem funkce s větším množstvím parametrů. To nám mj. umožňuje realizovat částečné vyhodnocení funkce (partial application), konkrétně zavoláním nějaké funkce (například funkce akceptující dva parametry) ve skutečnosti pouze s jediným parametrem.

Jenže otázkou je, co má být výsledkem volání takové funkce? Určitě ne výsledek implementované operace, protože nám chybí minimálně jeden argument pro to, aby byl výsledek vypočten a vrácen volajícím kódu. Ovšem můžeme provést částečný výpočet dosazením (jediného) předaného parametru a výsledek – tento částečný výpočet – vrátit. Výsledkem je tedy obecně částečně aplikovaná funkce (tedy například funkce, které byly v předchozím příkladu označeny symboly g a h). Jedná se o jeden ze způsobů, jak programově (tedy přímo za běhu aplikace) vytvářet nové funkce.

3. Operace curry zapisovaná formou konstrukce objektu

Curryfikace nějaké uživatelské či knihovní funkce se v knihovně Toolz provádí konstruktorem nazvaným curry. Podívejme se nyní na velmi jednoduchý demonstrační příklad, ve kterém z funkce add se dvěma parametry x a y vytvoříme novou funkci s jediným parametrem x. Po dosazení tohoto parametru do nové funkce se vrátí další funkce akceptující opět jediný parametr y. A zavoláním této funkce (po dosazení y) již získáme kýžený výsledek:

from toolz import curry
 
 
def add(x, y):
    return x + y
 
 
curried = curry(add)
 
print(curried)
print(curried(1))
print(curried(1)(2))  # pozor na umístění závorek!

Po spuštění tohoto příkladu zjistíme, že curried je funkce a výsledek curried(1) je taktéž funkce. Až dosazení dvojky do této nové funkce získáme součet, tedy hodnotu 3:

<function add at 0x7f58fe917920>
<function add at 0x7f58fe917920>
3

Curryfikaci lze pochopitelně provést i s funkcí s vyšším počtem parametrů. Příkladem může být curryfikace funkce se třemi parametry x, y a z:

from toolz import curry
 
 
def add3(x, y, z):
    return x + y + z
 
 
curried = curry(add3)
 
print(curried)
print(curried(1))
print(curried(1)(2))      # pozor na umístění závorek!
print(curried(1)(2)(3))   # pozor na umístění závorek!

Výsledkem curryfikace je funkce s jedním parametrem. Po jeho dosazení získáme další funkce akceptující jeden argument. Po dosazení tohoto argumentu získáme další funkci akceptující jeden argument. A konečně po jeho dosazení do této nové funkce se vrátí výsledek součtu:

<function add3 at 0x7fc8530f7920>
<function add3 at 0x7fc8530f7920>
<function add3 at 0x7fc8530f7920>
6

Příklad (i když opět poněkud umělý) na odvození funkce even z obecnější funkce divisible_by. Nová funkce bude použita pro získání sudých prvků z nekonečné sekvence:

from toolz import curry, take, iterate
 
 
def inc(x):
    return x+1
 
 
def divisible_by(y, x):
    return x % y == 0
 
 
curried = curry(divisible_by)
even = curried(2)
 
sequence = iterate(inc, 0)
evens = filter(even, sequence)
 
sequence = take(10, evens)
print(list(sequence))

Výsledek – prvních deset sudých prvků (pokud mezi sudé prvky budeme počítat nulu :-):

[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

4. Curryfikace funkce bez parametrů a funkce s jedním parametrem

Curryfikace se typicky provádí u funkcí s větším počtem parametrů, Ovšem knihovna toolz podporuje i curryfikaci funkce bez parametrů nebo funkce s jedním parametrem (i když to z teoretického pohledu postrádá smysl).

Vyzkoušejme se nejprve curryfikaci funkce bez parametrů:

from toolz import curry
 
 
def hello():
    print("Hello, world!")
 
 
curried = curry(hello)
print(hello)
print(curried)
curried()

Po spuštění tohoto demonstračního příkladu se postupně zobrazí reference na původní funkci, reference na curryfikovanou funkci a konečně výsledek volání curryfikované funkce. Povšimněte si, že původní funkce a curryfikovaná funkce mají zcela shodnou adresu, tudíž se jedná o tutéž funkci (hodnotu):

<function hello at 0x7f7bbbd63d30>
<function hello at 0x7f7bbbd63d30>
Hello, world!

Curryfikovat lze i funkci s jediným parametrem:

from toolz import curry
 
 
def inc(x):
    return x+1
 
 
curried = curry(inc)
print(inc)
print(curried)
print(curried())
print(curried(1))

Nyní budou výsledky vypadat následovně:

<function inc at 0x7f4e8a972d30>
<function inc at 0x7f4e8a972d30>
<function inc at 0x7f4e8a972d30>
2

5. Operace curry zapisovaná formou dekorátoru

Výše popsané volání konstruktoru curry se využívá především ve chvíli, kdy potřebujeme pracovat jak s původní funkcí, tak i s její curryfikovanou variantou. Ovšem pokud původní funkci nebudeme nikdy volat, lze curryfikaci zapsat jednodušším způsobem, a to konkrétně s využitím dekorátoru @curry (jedná se stále o stejný symbol).

Příklad použití pro funkci se dvěma parametry:

from toolz import curry
 
 
@curry
def add(x, y):
    return x + y
 
 
print(add)
print(add(1))
print(add(1)(2))  # pozor na umístění závorek!

Tentýž dekorátor, nyní ovšem použitý pro curryfikaci funkce se třemi parametry:

from toolz import curry
 
 
@curry
def add3(x, y, z):
    return x + y + z
 
 
print(add3)
print(add3(1))
print(add3(1)(2))      # pozor na umístění závorek!
print(add3(1)(2)(3))   # pozor na umístění závorek!

A jak již víme z předchozí kapitoly, je možné curryfikovat i funkce bez parametrů či funkce s jediným parametrem (i když je to vlastně zbytečná operace):

from toolz import curry
 
 
@curry
def hello():
    print("Hello, world!")
 
 
print(hello)
hello()

Výsledky:

<function hello at 0x7f0045162d30>
Hello, world!

Curryfikace funkce s jedním parametrem:

from toolz import curry
 
 
@curry
def inc(x):
    return x+1
 
 
print(inc)
print(inc())
print(inc(1))

Výsledky:

<function inc at 0x7f8e74af3d30>
<function inc at 0x7f8e74af3d30>
2

Přepis demonstračního příkladu, který získává prvních deset sudých prvků z nekonečné sekvence:

from toolz import curry, take, iterate
 
 
def inc(x):
    return x+1
 
 
@curry
def divisible_by(y, x):
    return x % y == 0
 
 
even = divisible_by(2)
 
 
sequence = iterate(inc, 0)
evens = filter(even, sequence)
 
sequence = take(10, evens)
print(list(sequence))

6. Curryfikace funkcí definovaných přímo v knihovně Toolz

Samozřejmě nám nic nebrání v curryfikaci těch funkcí, které jsou definovány přímo v knihovně Toolz. Vzhledem k tomu, že se mnohdy jedná o funkce určené pro zpracování sekvencí, jejichž první parametr (nebo parametry) modifikují prováděnou operaci, se jedná o poměrně užitečnou vlastnost.

Pokud například budeme chtít získat prvních deset prvků z konečné či nekonečné sekvence, lze postupovat takto:

from toolz.itertoolz import take
 
 
sequence = range(1, 1000)
 
first10 = take(10, sequence)
print(list(first10))

Výsledkem bude seznam prvních deseti prvků z delší sekvence:

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

Taktéž si pochopitelně můžeme zadefinovat vlastní funkci nazvanou například head, která s využitím take vrátí prvních deset prvků předané sekvence:

from toolz.itertoolz import take
 
 
sequence = range(1, 1000)
 
def head(s):
    return take(10, s)
 
first10 = head(sequence)
print(list(first10))

Podobnou operaci lze ovšem funkcionálně realizovat i tak, že použijeme curryfikaci s následným dosazením hodnoty 10 do curryfikované varianty funkce take:

from toolz import curry
from toolz.itertoolz import take
 
 
sequence = range(1, 1000)
 
curried = curry(take)
 
head = curried(10)
 
first10 = head(sequence)
print(list(first10))

Zkontrolujeme, zda dostaneme shodný výsledek, jako v předchozích dvou příkladech:

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

7. Import již curryfikovaných funkcí z knihovny Toolz

Jak jsme si již řekli v předchozí kapitole, může být v praxi výhodné použít funkce z knihovny Toolz v jejich curryfikované podobě. Ovšem to vyžaduje stále opakování stejného kódu:

curried = curry(take)

Aby se tento programový kód nemusel stále znovu a znovu opisovat pro všechny existující funkce, je přímo v knihovně Toolz nabízen podbalíček nazvaný toolz.curried, v němž jsou všechny původní funkce dostupné v curryfikované podobě (a pod stejným jménem – jména lze odlišit specifikací jmenného prostoru). Podívejme se na jednoduchý příklad:

from toolz.curried import take
 
 
sequence = range(1, 1000)
 
head = take(10)
 
first10 = head(sequence)
print(list(first10))

Výsledek bude totožný, jako tomu bylo u příkladů z předchozí kapitoly:

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

8. Curryfikované varianty standardních funkcí map, filter a reduce

V knihovně Toolz, konkrétně v podbalíčku toolz.curried, nalezneme i curryfikovanou podobu standardních funkcí map, filter a reduce. Použití těchto funkcí je jednoduché. Můžeme si například nechat vytvořit funkci vracející délky všech slov v předané sekvenci (například v seznamu):

from toolz.curried import map
 
message = "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua"
words = message.split()
 
lengths = map(len)
 
print(list(lengths(words)))

S výsledkem:

[5, 5, 5, 3, 5, 11, 10, 5, 3, 2, 7, 6, 10, 2, 6, 2, 6, 5, 6]

S původní funkcí map tuto operaci provést nelze:

from toolz.curried import map
 
message = "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua"
words = message.split()
 
lengths = map(len)
 
print(list(lengths(words)))

Tento skript nebude možné spustit:

Traceback (most recent call last):
  File "un_curried_map.py", line 4, in <module>
    lengths = map(len)
TypeError: map() must have at least two arguments.

9. Kompozice funkcí

V několika funkcionálních jazycích (a taktéž v jazycích typu FORTH, Factor nebo Joy) je umožněno vytvářet takzvané kompozice funkcí, tj. nové funkce, které vzniknou vzájemným voláním funkcí existujících, ovšem s tím, že se při konstrukci kompozice neřeší takové „maličkosti“, jako jsou názvy či počty předávaných parametrů. Ovšem s kompozicí funkcí se setkáme i v dalších jazycích, i když zde se celá technika může nazývat jinak (pipeline) atd. Tato možnost je dostupná i v knihovně Toolz, kde nalezneme trojici funkcí vyššího řádu:

1. compose
2. compose_left
3. pipe

Tyto funkce si ukážeme v navazujících kapitolách na několika praktických příkladech.

10. Operace compose

Podívejme se na velmi jednoduchý příklad, který provede kompozici standardních funkcí len a str, a to konkrétně tak, že se vstupní parametr nejprve převede na řetězec funkcí str a následně se vypočte a vrátí délka tohoto řetězce funkcí len. Kompozice je tedy len(str(vstup)):

from toolz import compose
 
 
composed = compose(len, str)
 
print(composed)
print(composed(0))
print(composed(42))
print(composed(1000))

Výsledek by měl vypadat následovně – nejprve se vypíše typ hodnoty composed a následně se vypíšou délky řetězců „0“, „42“ a „1000“:

Compose(<built-in function len>, <class 'str'>)
1
2
4

Ovšem můžeme použít i funkce s větším množstvím parametrů. Například lze vytvořit kompozici z funkce pro součet dvou hodnot s následným vynásobením mezivýsledku dvojkou:

from toolz import compose
 
 
def add(x, y):
    return x+y
 
 
def double(x):
    return 2*x
 
 
composed = compose(double, add)
 
print(composed(2, 3))
print(composed(-2, -3))

Tento příklad by měl po svém spuštění vypsat následující výsledky:

10
-10

A pro úplnost si ukažme ještě kompozici získanou ze třech funkcí, konkrétně abs(double(add(x,y))):

from toolz import compose
 
 
def add(x, y):
    return x+y
 
 
def double(x):
    return 2*x
 
 
def abs(x):
    if x < 0:
        return -x
    return x
 
 
composed = compose(abs, double, add)
 
print(composed(2, 3))
print(composed(-2, -3))

Nyní budou výsledky vypadat takto:

10
10

Můžeme ovšem namísto pojmenovaných funkcí použít i anonymní funkce a celou kompozici zapsat jediným výrazem:

from toolz import compose
 
 
composed = compose(
        lambda x: -x if x<0 else x,
        lambda x: x*2,
        lambda x, y: x+y)
 
print(composed(2, 3))
print(composed(-2, -3))

11. Operace compose_left

Při tvorbě kompozice z funkcí je pro většinu programátorů přirozenější číst kompozici zleva doprava. V tomto případě je výhodnější namísto compose použít funkci vyššího řádu nazvanou compose_left (pozor na zmatení – ve Funcy se tato operace jmenovala rcompose!).

Zkusme si předchozí trojici demonstračních příkladů přepsat tak, aby se namísto compose použila funkce compose_left. Pochopitelně musíme prohodit i pořadí funkcí, které se do compose_(left) předávají.

První příklad, který nejprve převede hodnotu na řetězec a posléze vypočte délku tohoto řetězce:

from toolz import compose_left
 
 
composed = compose_left(str, len)
 
print(composed)
print(composed(0))
print(composed(42))
print(composed(1000))

Druhý příklad, který sečte předané hodnoty a následně se výsledek součtu vynásobí dvěma:

from toolz import compose_left
 
 
def add(x, y):
    return x+y
 
 
def double(x):
    return 2*x
 
 
composed = compose_left(add, double)
 
print(composed(2, 3))
print(composed(-2, -3))

A konečně si přepišme příklad třetí, který z výsledku součtu následovaného vynásobením dvěma vypočte absolutní hodnotu:

from toolz import compose_left
 
 
def add(x, y):
    return x+y
 
 
def double(x):
    return 2*x
 
 
def abs(x):
    if x < 0:
        return -x
    return x
 
 
composed = compose_left(add, double, abs)
 
print(composed(2, 3))
print(composed(-2, -3))

12. Vytvoření kolony (pipe) funkcí pipe

Od operací compose a compose_left je to již jen malý krůček k velmi užitečné operaci – konstrukci kolony s předáním hodnot do této kolony. Kolonou je v tomto případě myšlena sekvence funkcí. Vstupní hodnoty jsou předány první funkci, výsledek této funkce je předán druhé funkci atd. až výsledek poslední funkce je hodnotou, která je z kolony vrácena volajícímu kódu. Kolona je tedy vlastně vytvořena kombinací dvou kroků:

1. Vytvoření kompozice funkcí (compose_left)
2. Zavolání výsledné funkce s předáním parametrů

Celý koncept si můžeme jednoduše otestovat:

from toolz import pipe
 
 
print(pipe(1, str, len))
print(pipe(42, str, len))
print(pipe(1000, str, len))

Výsledky:

1
2
4

Kolona se třemi funkcemi, které se postupně volají:

from toolz import pipe
 
 
def double(x):
    return x*2
 
 
print(pipe(1, abs, double))
print(pipe(42, abs, double))
print(pipe(1000, abs, double))

Výsledky:

2
84
2000

Samozřejmě můžeme použít i anonymní funkce a nikoli pouze funkce pojmenované:

from toolz import pipe
 
 
print(pipe(1, abs, lambda x: x*2))
print(pipe(42, abs, lambda x: x*2))
print(pipe(1000, abs, lambda x: x*2))

Výsledky budou v tomto případě pochopitelně totožné s předchozím demonstračním příkladem:

2
84
2000

13. Obsah závěrečného článku o knihovně Toolz

V posledním článku o knihovně Toolz si popíšeme podbalíček nazvaný dicttoolz. Funkce v něm definované připomínají práci se slovníky v programovacím jazyce Clojure – jedná se tedy o funkcionální přístup, kdy výsledkem nějaké operace je nový slovník a nikoli modifikace existujícího slovníku.

14. Repositář s demonstračními příklady

Všechny Pythonovské skripty, které jsme si prozatím v tomto seriálu ukázali, naleznete na adrese https://github.com/tisnik/most-popular-python-libs. Následují odkazy na jednotlivé příklady (pro jejich spuštění je nutné mít nainstalovánu některou z podporovaných verzí Pythonu 3, a pro dnešní příklady i výše zmíněnou knihovnu funcy):

15. Odkazy na Internetu

1. Getting started with functional programming in Python using the toolz library
   https://opensource.com/ar­ticle/18/10/functional-programming-python-toolz
2. Toolz module in Python
   https://www.geeksforgeeks.org/toolz-module-in-python/
3. functools — Higher-order functions and operations on callable objects
   https://docs.python.org/3/li­brary/functools.html
4. Functional Programming HOWTO
   https://docs.python.org/3/how­to/functional.html
5. Functional Programming in Python: When and How to Use It
   https://realpython.com/python-functional-programming/
6. Functional Programming With Python
   https://realpython.com/learning-paths/functional-programming/
7. Awesome Functional Python
   https://github.com/sfermigier/awesome-functional-python
8. Currying
   https://en.wikipedia.org/wi­ki/Currying
9. Currying in Python – A Beginner’s Introduction
   https://www.askpython.com/pyt­hon/examples/currying-in-python
10. Fundamental Concepts in Programming Languages
    https://en.wikipedia.org/wi­ki/Fundamental_Concepts_in_Pro­gramming_Languages
11. When should I use function currying?
    https://stackoverflow.com/qu­estions/24881604/when-should-i-use-function-currying
12. Toolz
    https://github.com/pytool­z/toolz/tree/master
13. Coconut: funkcionální jazyk s pattern matchingem kompatibilní s Pythonem
    https://www.root.cz/clanky/coconut-funkcionalni-jazyk-s-pattern-matchingem-kompatibilni-s-pythonem/
14. A HITCHHIKER'S GUIDE TO functools
    https://ep2021.europython­.eu/media/conference/slides/a-hitchhikers-guide-to-functools.pdf
15. Coconut aneb funkcionální nadstavba nad Pythonem (2.část)
    https://www.root.cz/clanky/coconut-aneb-funkcionalni-nadstavba-nad-pythonem-2-cast/
16. Knihovny pro zpracování posloupností (sekvencí) v Pythonu
    https://www.root.cz/clanky/knihovny-pro-zpracovani-posloupnosti-sekvenci-v-pythonu/
17. clj – repositář s knihovnou
    https://github.com/bfontaine/clj
18. clj 0.1.0 – stránka na PyPi
    https://pypi.python.org/py­pi/clj/0.1.0
19. Clojure aneb jazyk umožňující tvorbu bezpečných vícevláknových aplikací pro JVM (4.část – kolekce, sekvence a lazy sekvence)
    https://www.root.cz/clanky/clojure-aneb-jazyk-umoznujici-tvorbu-bezpecnych-vicevlaknovych-aplikaci-pro-jvm-4-cast-kolekce-sekvence-a-lazy-sekvence/
20. Clojure a bezpečné aplikace pro JVM: sekvence, lazy sekvence a paralelní programy
    https://www.root.cz/clanky/clojure-a-bezpecne-aplikace-pro-jvm-sekvence-lazy-sekvence-a-paralelni-programy/
21. Coconut: Simple, elegant, Pythonic functional programming
    http://coconut-lang.org/
22. coconut (Python package index)
    https://pypi.python.org/pypi/coconut/
23. Coconut Tutorial
    http://coconut.readthedoc­s.io/en/master/HELP.html
24. Coconut FAQ
    http://coconut.readthedoc­s.io/en/master/FAQ.html
25. Coconut Documentation
    http://coconut.readthedoc­s.io/en/master/DOCS.html
26. Coconut na Redditu
    https://www.reddit.com/r/Pyt­hon/comments/4owzu7/coconut_fun­ctional_programming_in_pyt­hon/
27. Repositář na GitHubu
    https://github.com/evhub/coconut
28. Object-Oriented Programming — The Trillion Dollar Disaster
    https://betterprogramming.pub/object-oriented-programming-the-trillion-dollar-disaster-92a4b666c7c7
29. Goodbye, Object Oriented Programming
    https://cscalfani.medium.com/goodbye-object-oriented-programming-a59cda4c0e53
30. So You Want to be a Functional Programmer (Part 1)
    https://cscalfani.medium.com/so-you-want-to-be-a-functional-programmer-part-1–1f15e387e536
31. So You Want to be a Functional Programmer (Part 2)
    https://cscalfani.medium.com/so-you-want-to-be-a-functional-programmer-part-2–7005682cec4a
32. So You Want to be a Functional Programmer (Part 3)
    https://cscalfani.medium.com/so-you-want-to-be-a-functional-programmer-part-3–1b0fd14eb1a7
33. So You Want to be a Functional Programmer (Part 4)
    https://cscalfani.medium.com/so-you-want-to-be-a-functional-programmer-part-4–18fbe3ea9e49
34. So You Want to be a Functional Programmer (Part 5)
    https://cscalfani.medium.com/so-you-want-to-be-a-functional-programmer-part-5-c70adc9cf56a
35. So You Want to be a Functional Programmer (Part 6)
    https://cscalfani.medium.com/so-you-want-to-be-a-functional-programmer-part-6-db502830403
36. Why Programmers Need Limits
    https://cscalfani.medium.com/why-programmers-need-limits-3d96e1a0a6db
37. Infographic showing code complexity vs developer experience
    https://twitter.com/rossi­pedia/status/1580639227313676288
38. Python's reduce(): From Functional to Pythonic Style
    https://realpython.com/python-reduce-function/
39. What is the problem with reduce()?
    https://stackoverflow.com/qu­estions/181543/what-is-the-problem-with-reduce
40. The fate of reduce() in Python 3000
    https://www.artima.com/we­blogs/viewpost.jsp?thread=98196
41. Reading 16: Map, Filter, Reduce
    http://web.mit.edu/6.031/www/sp22/clas­ses/16-map-filter-reduce/
42. Currying
    https://sw-samuraj.cz/2011/02/currying/
43. Používání funkcí v F#
    https://docs.microsoft.com/cs-cz/dotnet/fsharp/tutorials/using-functions
44. Funkce vyššího řádu
    http://naucte-se.haskell.cz/funkce-vyssiho-radu
45. Currying (Wikipedia)
    https://en.wikipedia.org/wi­ki/Currying
46. Currying (Haskell wiki)
    https://wiki.haskell.org/Currying
47. Haskell Curry
    https://en.wikipedia.org/wi­ki/Haskell_Curry
48. Moses Schönfinkel
    https://en.wikipedia.org/wi­ki/Moses_Sch%C3%B6nfinkel
49. ML – funkcionální jazyk s revolučním typovým systémem
    https://www.root.cz/clanky/ml-funkcionalni-jazyk-s-revolucnim-typovym-systemem/
50. Funkce a typový systém programovacího jazyka ML
    https://www.root.cz/clanky/funkce-a-typovy-system-programovaciho-jazyka-ml/
51. Curryfikace (currying), výjimky a vlastní operátory v jazyku ML
    https://www.root.cz/clanky/curryfikace-currying-vyjimky-a-vlastni-operatory-v-jazyku-ml/
52. Primer on Python Decorators
    https://realpython.com/primer-on-python-decorators/
53. Python Decorators
    https://www.programiz.com/python-programming/decorator
54. PythonDecorators (Python Wiki)
    https://wiki.python.org/mo­in/PythonDecorators
55. Funcy na GitHubu
    https://github.com/suor/funcy/
56. Welcome to funcy documentation!
    https://funcy.readthedocs­.io/en/stable/
57. Funcy cheatsheet
    https://funcy.readthedocs­.io/en/stable/cheatsheet.html
58. PyToolz API Documentation
    https://toolz.readthedocs­.io/en/latest/index.html
59. Curry v knihovně Toolz
    https://toolz.readthedocs­.io/en/latest/curry.html
60. Compose v knihovně Toolz
    https://toolz.readthedocs­.io/en/latest/api.html#to­olz.functoolz.compose
61. Pipe v knihovně Toolz
    ihttps://toolz.readthedoc­s.io/en/latest/api.html#to­olz.functoolz.pipe
62. Toolz (PyToolz) na GitHubu
    https://github.com/pytoolz/toolz
63. Fn.py: enjoy FP in Python
    https://github.com/kachayev/fn.py
64. Funcy na PyPi
    https://pypi.org/project/funcy/
65. Underscore aneb další knihovna pro funkcionální programování v JavaScriptu
    https://www.root.cz/clanky/underscore-aneb-dalsi-knihovna-pro-funkcionalni-programovani-v-javascriptu/
66. Funkce vyššího řádu v knihovně Underscore
    https://www.root.cz/clanky/funkce-vyssiho-radu-v-knihovne-underscore/
67. Awesome functional Python
    https://github.com/sfermigier/awesome-functional-python
68. lispy
    https://pypi.org/project/lispy/
69. clojure_py na indexu PyPi
    https://pypi.python.org/py­pi/clojure_py
70. PyClojure
    https://github.com/eigenhom­bre/PyClojure
71. Hy na GitHubu
    https://github.com/hylang/hy
72. Hy: The survival guide
    https://notes.pault.ag/hy-survival-guide/
73. Hy běžící na monitoru terminálu společnosti Symbolics
    http://try-hy.appspot.com/
74. Welcome to Hy’s documentation!
    http://docs.hylang.org/en/stable/
75. Hy na PyPi
    https://pypi.org/project/hy/#des­cription
76. Getting Hy on Python
    https://lwn.net/Articles/596626/