Obsah
1. Funkcionální programovací jazyk F#
2. Od programovacího jazyka ML k jazyku F#
3. Prapředek F#: programovací jazyk ML
4. Ukázky syntaxe a sémantiky programovacího jazyka ML
5. Další informace o jazyku ML, resp. Standard ML
6. Od Standard ML k jazykům Caml a OCaml
7. Ukázky syntaxe a sémantiky programovacího jazyka OCaml
8. Od OCamlu k programovacímu jazyku F#
10. Pískoviště (playground) pro první seznámení s možnostmi programovacího jazyka
11. Webová konzole pro programovací jazyk F#
12. Univerzální webové prostředí Repl.it a jazyk F#
13. Konzole s interpretrem jazyka F# (fsi)
14. Dva základní koncepty, na nichž je jazyk F# postaven: funkce a datové typy
15. Explicitní specifikace typu argumentů funkcí
17. Seriál o OCaml – async v praxi?
18. Repositář s demonstračními příklady
1. Funkcionální programovací jazyk F#
„Writing C# feels like filling out government forms in triplicate.“
Letos slavíme další výročí, které se vztahuje k (historickým) programovacím jazykům. Před padesáti (!) lety totiž začala práce na tvorbě standardu programovacího jazyka ML, přičemž výsledek byl nazván – pozor, překvapení – StandardML neboli zkráceně SML. S jazykem ML jsme se již na stránkách Roota seznámili (viz odkazy uvedené níže), ovšem co je důležité: tento jazyk se stal základem pro vývoj dalších programovacích jazyků, mezi něž patří CAML (Categorical Abstract Machine Language), OCaml (Objective Caml) a v neposlední řadě i jazyk F#. A právě tímto nepochybně velmi zajímavým a v praxi používaným (ve své nice) programovacím jazykem se budeme zabývat v nově vznikajícím seriálu.
Obrázek 1: Logo programovacího jazyka F# (ve Státech asi nemají znalost středoevropských reálií, když vybrali toto logo).
2. Od programovacího jazyka ML k jazyku F#
„Sometimes, the elegant implementation is a function. Not a method. Not a class. Not a framework. Just a function.“
John Carmack
Programovací jazyk F# pochopitelně nevznikl na zelené louce. Jeho prapředkem je programovací jazyk nazvaný jednoduše ML, z něhož byl o několik let později odvozen jazyk Standard ML, dále jazyk nazvaný Caml a z něho OCaml. A právě na těchto (nutno podotknout, že dosti pevných) základech vznikl programovací jazyk F#, který byl navíc navržen takovým způsobem, aby velmi dobře zapadl do ekosystému postaveného okolo frameworku .NET, v němž se kromě toho používají jazyky C# a Visual Basic odvozené z Algolské větve programovacích jazyků. Ovšem při vzniku F# se jeho autoři inspirovali i některými dalšími programovacími jazyky, které obvykle neřadíme do „ML větve“. Patří sem například Erlang, Haskell (i když ten je inspirován jazykem ML), Python či programovací jazyk Scala.
Obrázek 2: Jazyky více či méně inspirované poněkud přehlíženým jazykem ML, jenž však měl a dodnes má velký vliv na celý tento obor IT.
Zdroj: https://erkin.party/blog/190208/spaghetti/
3. Prapředek F#: programovací jazyk ML
Připomeňme si nyní v krátkosti historii vývoje jazyka ML. Programovací jazyk ML vznikl v univerzitním prostředí ve Velké Británii, takže se jedná o další oblast, v níž vznikl nějaký důležitý koncept v oblasti teorie programovacích jazyků (mezi další takové důležité a známé „líhně“ patřily pochopitelně USA s MIT, Bell Labs, IBM a taktéž kontinentální Evropa s Prologem a algolskou a následně i pascalskou větví programovacích jazyků). První kroky vedoucí později ke vzniku jazyka ML provedla na začátku sedmdesátých let minulého století skupina vědců z laboratoře pro výzkum umělé inteligence z univerzity v Edinburgu. Jak bylo v té době v oblasti AI prakticky nepsaným standardem, používal se převážně programovací jazyk LISP, který byl ovšem doplněný o Prolog, což byla tehdy žhavá novinka, protože Prolog vznikl v roce 1972.
Výše zmíněná skupina pro výzkum v oblasti umělé inteligence pracovala na vývoji systému pojmenovaného LCF (plným názvem Logic For Computable Functions), jenž byl určen pro dokazování teorémů. Tento systém byl naprogramován v LISPu. Poněkud předbíháme, ale na tomto místě je vhodné poznamenat, že ideové stopy LISPu jsou v jazyku ML poměrně dobře patrné, i když nikoli na syntaktické úrovni (tam je naopak ML jazyk s minimem kulatých závorek, na rozdíl od LISPu). A právě pro potřeby LCF vznikl nový (tehdy vlastně doménově specifický) jazyk ML. To vlastně znamená, že samotný ML byl pouze vedlejším produktem práce na LCF, teprve poději došlo k osamostatnění ML.
První varianta ML pro LCF vznikala v období 1973 až 1978. Původně byly zdrojové kódy transpilovány do LISPu a teprve poté překládány do strojového (objektového) kódu. Ovšem kromě technických detailů (jakkoli jsou zajímavé) je důležité, kdo se na vývoji ML podílel a jaké myšlenky zde byly využity. Jednou z inspirací byl jazyk ISWIM (If you See What I Mean) Petera Landina z šedesátých let. Tento jazyk byl založen na lambda kalkulu, podporoval funkce vyššího řádu a používal dynamické typování a lexikální obory platnosti. Peter Landin pro tento projekt vytvořil operátor J. Na vývoji ML se nepřímo podílel i Christopher Strachey, jenž dříve vytvořil jazyk CPL, což je praprapředek céčka (CPL → BCPL → B → C). Mimochodem, právě Christopher Strachey zavedl v IT několik nových termínů, například od něj pochází označení „syntactic sugar“.
V jazyce ML se objevilo i automatické odvozování datových typů (type inference), což je technika, která byla shrnuta v roce 1978 pod jménem „Hindley-Milner type inference“. A ve stejném roce byl ML pro LCF konečně dokončen.
Vzhledem k tomu, že ML byl součástí LCF a nebylo ho možné používat mimo tento systém (proto se taktéž někdy setkáme s označením LCF/ML), objevily se snahy o plné oddělení ML jako samostatného jazyka. Takto vznikl „ML under VAX“ neboli zkráceně „VAX ML“. Jednalo se o samostatně použitelnou variantu ML, která byla naprogramována v Pascalu. Překladač do strojového kódu VAXu byl dokončen v roce 1981. Prakticky právě od této chvíle se začala psát historie skutečně dostupného ML. Ostatně je to patrné i na tom, že o rok později byl jazyk portován do Unixu (stále v Pascalu). Později byl runtime jazyka přepsán do C, ovšem samotný překladač zůstal v Pascalu.
V roce 1983 se autoři programovacího jazyka ML setkali na universitě v Edinburgu s cílem formálně jazyk ML specifikovat. Na rozdíl od například Pythonu měl být tedy jazyk ML založen na formální definici a nikoli na referenční implementaci. Výsledkem tohoto setkání byl popis ML, článek „Compiling a Functional Language“ a zhruba v této době se namísto ML začalo používat označení Standard ML neboli zkráceně SML.
4. Ukázky syntaxe a sémantiky programovacího jazyka ML
Sémantika programovacího jazyka ML měla velký vliv na jazyky CAML, OCaml i F#. Syntaxe se sice později poněkud změnila, ale i tak uvidíme, že příbuznost těchto jazyků je stále patrná a dokonce je možné některé realizace algoritmů beze změny přenést do novějšího jazyka. Pro zajímavost se nyní podívejme na způsob implementace výpočtu Fibonacciho posloupnosti v tomto jazyku. Nejdříve si ukážeme naivní implementaci výpočtu s využitím rekurze (ovšem nikoli optimalizace na základě tail rekurze) v programovacím jazyku Standard ML:
(* Naivní implementace výpočtu Fibonacciho posloupnosti *)
fun fib n =
if n = 0 then 0 else
if n = 1 then 1 else
fib (n - 1) + fib (n - 2);
fib 10;
Využít ovšem v tomto případě můžeme i pattern matching (který je v jiných jazycích „znovuobjevován“ a mnohdy vývojářské veřejnosti představován jako žhavá novinka). Použití pattern matchingu vede k elegantnějšímu způsobu zápisu programového kódu:
(* Implementace výpočtu Fibonacciho posloupnosti s využitím pattern matchingu *) fun fib 0 = 0 | fib 1 = 1 | fib n = fib (n - 1) + fib (n - 2); fib 10;
Na obou výše uvedených demonstračních příkladech můžeme vidět syntaxi, která je typická pro většinu programovacích jazyků z rodiny ML. Například při deklaraci funkce se formální parametry nezapisují do závorek a při volání funkce je možné závorky vynechat ve chvíli, kdy je zápis jednoznačný. Taktéž zápis pattern matchingu se znakem roury je pro mnoho jazyků z rodiny ML typický (ale dále uvidíme, že i on se postupem doby změnil).
A navíc si povšimněte, že i když je ML staticky a navíc i striktně typovaný programovací jazyk, není ve funkcích datový typ ve skutečnosti ani jednou specifikován! O doplnění datových typů se stará mechanismus známý pod jménem type inference, jenž je mimochodem taktéž „znovuobjevován“ a jeho slabší variantu nalezneme například v programovacím jazyku Go.
To, že je typový systém jazyka silný, si můžeme ověřit snadno – pokusíme se do funkce fib předat nějakou nekorektní hodnotu:
fib "www.root.cz"; Elaboration failed: Type clash. Functions of type "int → int" cannot take an argument of type "string": Cannot merge "int" and "string".
popř.:
fib 1.5; Elaboration failed: Type clash. Functions of type "int → int" cannot take an argument of type "real": Cannot merge "int" and "real".
Další ukázka poněkud pokročilejšího pattern matchingu pro rekurzivně zapsaný výpočet délky seznamu:
(* Implementace funkce length založená na pattern matchingu *) fun length([]) = 0 | length(head::tail) = 1 + length(tail);
což lze ještě více zkrátit na:
(* Implementace funkce length založená na pattern matchingu *) fun length([]) = 0 | length(_::tail) = 1 + length(tail);
Příklad použití této funkce:
length []; > val it = 0: int; length [1]; > val it = 1: int; length [1,2,3,4]; > val it = 4: int; length ["foo", "bar", "baz"]; > val it = 3: int;
A pochopitelně i zde je prováděna striktní typová kontrola:
length "www.root.cz"; Elaboration failed: Type clash. Functions of type "'a list → int" cannot take an argument of type "string": Cannot merge "'a list" and "string".
5. Další informace o jazyku ML, resp. Standard ML
S programovacím jazykem ML jsme se již na stránkách Rootu seznámili v miniseriálu Funkcionální programovací jazyk ML, který měl pouhé tři díly (mj. i kvůli tomu, že je tento jazyk pojat poměrně minimalisticky – například nemá OO systém, jeho standardní knihovna je relativně malá atd.):
- ML – funkcionální jazyk s revolučním typovým systémem
https://www.root.cz/clanky/ml-funkcionalni-jazyk-s-revolucnim-typovym-systemem/ - Funkce a typový systém programovacího jazyka ML
https://www.root.cz/clanky/funkce-a-typovy-system-programovaciho-jazyka-ml/ - 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/
Demonstrační příklady napsané v jazyku ML lze najít v repositáři https://github.com/tisnik/ml-examples.
6. Od Standard ML k jazykům Caml a OCaml
První polovina osmdesátých let minulého století je z hlediska historie programovacích jazyků zajímavé období, protože se prakticky „všude“ začalo mluvit o objektově orientovaném programování jako o stříbrné kulce, která má vyřešit (skoro) všechny programátorské problémy a současně se předpokládalo, že právě objektově orientované programování bude paradigmatem používaným v budoucnu (což se nakonec ukázal být pravdivý předpoklad, i když nakonec zvítězilo „třídní OOP“ a nikoli koncept posílání zpráv, tedy původní myšlenka OOP). Ostatně v roce 1983 vzniklo C++, v roce 1989 pak C++2.0. Začátek práce na Javě, tedy na dalším široce rozšířeném objektově orientovaném jazyku, se datuje do roku 1991, první oficiální verze pak byla vydána v roce 1995. A nastoleného tématu se chytily i další společnosti, takže například vznikly assemblery podporující objektově orientované programování (což v praxi nebyla tak úplně pravda, ale na krabici se to pěkně vyjímalo).
V rámci plánů dalších verzí programovacího jazyka ML (přednášky ML-2000) se začalo mluvit o podpoře objektově orientovaného programování i v tomto jazyce. Nejprve v roce 1985 vznikl programovací jazyk Caml, resp. psaný i CAML (Categorical Abstract Machine Language), jehož poslední verze nabízela OO vrstvu. Na základě zkušeností s Camlem byl v roce 1996 vydán programovací jazyk OCaml (Objective Caml), jenž je používán dodnes a jemuž se jazyk F# do značné míry podobá.
Obrázek 3: Logo jazyka OCaml (když zvíře míří doprava, jde o OCaml, když doleva, tak je to Perl :-)
7. Ukázky syntaxe a sémantiky programovacího jazyka OCaml
Opět se podívejme na způsob zápisu algoritmu pro výpočet Fibonacciho posloupnosti, tentokrát ovšem nikoli v ML, ale v programovacím jazyku OCaml. První verze algoritmu používá rekurzi (ovšem nikoli v tail pozici):
let rec fib n =
if n < 2 then
n
else
fib (n - 1) + fib (n - 2)
;;
fib 10
Druhý příklad je založen na použití pattern matchingu. Zápis se poněkud liší od Standard ML, ovšem kostra programu i jeho sémantika zůstala do značné míry zachována:
let rec fib = function
0 -> 0
| 1 -> 1
| n -> fib (n-1) + fib (n-2)
fib 10
A konečně se podívejme na poněkud složitější implementaci používající tail rekurzi, která je překladačem optimalizována do formy programové smyčky:
let fib n =
let rec tailr i a b =
if i = 0 then a else tailr (pred i) b (a + b)
in
tailr n 0 1
fib 10
Výše uvedené demonstrační příklady si opět můžete otestovat bez toho, aby bylo nutné instalovat ekosystém jazyka OCaml. Postačuje navštívit stránku https://ocaml.org/play nebo https://try.ocaml.pro/. Existuje i alternativní webové rozhraní pro OCaml, které naleznete na adrese https://patricoferris.github.io/try-eio/. V tomto prostředí se provádí překlad zapsaných zdrojových kódů do JavaScriptu.
Obrázek 4: Interaktivní REPL jazyka OCaml.
8. Od OCamlu k programovacímu jazyku F#
Programovací jazyk F# vznikl jako výsledek snahy o portaci výše zmíněného programovacího jazyka OCaml do ekosystému budovaného okolo platformy .NET. Ostatně původně se tento projekt měl jmenovat Caml.NET. Později došlo k jeho přejmenování na F#, což odkazuje na jazyk C# i na funkcionální prvky jazyků ML/Caml/OCaml/F#. F# byl oproti OCamlu v mnoha ohledech rozšířen (což ovšem nemusí být vždy pozitivní směr vývoje) a především upraven do takové podoby, aby dokázal dobře kooperovat v prostředí .NET, které je objektové a NEfunkcionální.
Obrázek 5: Vývoj jazyka F#.
Za vznikem a vývojem Caml.NET a F# stál Don Syme a později, společně s produktizací jazyka F#, vznikl celý vývojový tým, ovšem vývoj je řízen F# Software Foundation. V následující tabulce jsou vypsány jednotlivé verze jazyka F# i s daty vydání těchto verzí:
| Verze jazyka F# | Datum vydání verze |
|---|---|
| 1.x | Květen 2005 |
| 2.0 | Srpen 2010 |
| 3.0 | Listopad 2012 |
| 3.1 | Listopad 2013 |
| 4.0 | Leden 2016 |
| 4.1 | Březen 2018 |
| 4.5 | Srpen 2018 |
| 4.6 | Březen 2019 |
| 4.7 | Září 2019 |
| 5.0 | Listopad 2020 |
| 6.0 | Listopad 2021 |
| 7.0 | Listopad 2022 |
9. Jak začít s jazykem F#?
Jaké programy je nutné nainstalovat v případě, že si budete chtít otestovat základní vlastnosti programovacího jazyka F#? V případě, že budete chtít plnohodnotnou instalaci F# i dalších nástrojů postavených okolo platformy .NET, lze postupovat podle (relativně krátkého) návodu, jenž je dostupný na stránkách https://fsharp.org/use/linux/. Po instalaci platformy .NET lze spustit jazyk F# v režimu interpretru příkazem:
$ dotnet fsi
$ curl -sSL https://dot.net/v1/dotnet-install.sh | bash /dev/stdin --version latest dotnet-install: Attempting to download using aka.ms link https://dotnetcli.azureedge.net/dotnet/Sdk/6.0.413/dotnet-sdk-6.0.413-linux-x64.tar.gz dotnet-install: Extracting zip from https://dotnetcli.azureedge.net/dotnet/Sdk/6.0.413/dotnet-sdk-6.0.413-linux-x64.tar.gz dotnet-install: Installed version is 6.0.413 dotnet-install: Adding to current process PATH: `/home/tester/.dotnet`. Note: This change will be visible only when sourcing script. dotnet-install: Note that the script does not resolve dependencies during installation. dotnet-install: To check the list of dependencies, go to https://learn.microsoft.com/dotnet/core/install, select your operating system and check the "Dependencies" section. dotnet-install: Installation finished successfully.
Velmi konformní prostředí pro vývoj v programovacím jazyku F# poskytuje především Visual Studio Code po instalaci přídavného modulu ionide. Tento projekt, resp. LSP server, jenž je jeho součástí (FsAutoComplete), je ovšem možné využít například i v programátorských textových editorech Emacs a Vim (což si ukážeme v navazujícím článku).
Další možnost spočívá v použití programovacího jazyka F# v Jupyter Notebooku, což je projekt, kterým jsme se již na stránkách Roota několikrát zabývali, a to konkrétně v těchto článcích [1] [2] [3] a [4]. Integrace jazyka F# s Jupyter Notebookem je realizována projektem interactive.
10. Pískoviště (playground) pro první seznámení s možnostmi programovacího jazyka
V následujících dvou kapitolách se seznámíme se dvěma webovými „pískovišti“ (playground). Jedná se o prostředí realizované (z pohledu uživatele) ve webovém prohlížeči, ovšem na rozdíl od plnohodnotných integrovaných vývojových prostředí zde nenalezneme všechny v současnosti očekávané vlastnosti (například plnohodnotný debugger atd.). Ovšem i přesto jsou pískoviště poměrně často používána, například při výuce nebo při zkoušení vlastností programovacích jazyků. S trochou nadsázky je možné říci, že podobná pískoviště existují pro prakticky všechny moderní programovací jazyky, což je ostatně jen dobře, protože nový jazyk je možné si díky tomu velmi snadno a rychle vyzkoušet i bez nutnosti jeho instalace, konfigurace, konfigurace vývojového prostředí, konfigurace LSP (Language Server Protocol), DAP (Debug Adapter Protocol) atd. Mezi výhody mnoha pískovišť patří i možnost sdílení kódu s dalšími uživateli (většinou postačuje pouze sdílet adresu/URL s kódem).
Obrázek 6: Prostředí Quite BASICu, které se snaží o reinkarnaci klasického BASICU, ovšem ve webovém ekosystému. Jedná se vlastně o poněkud sofistikovanější pískoviště.
11. Webová konzole pro programovací jazyk F#
Webové rozhraní pískoviště pro programovací jazyk F# je možné nalézt na adrese https://try.fsharp.org/. Alternativní pískoviště nalezneme na adrese https://tryfsharp.fsbolero.io/. To vypadá následovně (mimochodem je zajímavé, že se zde používá technologie WebAssembly):
Obrázek 7: Webové prostředí pískoviště pro programovací jazyk F#.
V porovnání s ostatními pískovišti je pískoviště pro jazyk F# vybaveno několika užitečnými technologiemi, které známe z běžných plnohodnotných IDE. Především textový editor zabudovaný do pískoviště podporuje zvýraznění syntaxe (to chybí například u pískoviště pro programovací jazyk Go), ale navíc je podporováno i automatické doplňování kódu, které je kontextové a dokonce se u nabízených funkcí zobrazuje i přesná informace o datových typech (ona by ostatně byla ostuda, kdyby tato technologie nefungovala zrovna u jazyka F#). I z tohoto důvodu se může jednat o stránku vhodnou pro první seznámení s F# (pokud se vám například nechce do Linuxu instalovat všechny závislosti, které F# ve formě nativní aplikace má).
Obrázek 8: Rekurzivní výpočet faktoriálu v programovacím jazyku F#.
Obrázek 9: Výpočet faktoriálu s využitím koncové rekurze (ta se přeloží na programovou smyčku).
Obrázek 10: Výpočet Mandelbrotovy množiny (kód převzat z Rosetta Code).
12. Univerzální webové prostředí Repl.it a jazyk F#
Kromě relativně triviálního pískoviště můžeme programovací jazyk F# využít i v prakticky plnohodnotném webovém integrovaném prostředí Repl.it, které je dostupné na adrese https://replit.com/. Jedná se o komerční produkt, jenž je však možné používat (i když pochopitelně s omezenými funkcemi – omezeným časem CPU i omezenou spotřebou RAM) zdarma; viz též https://replit.com/pricing, popř. Using Replit for free s podrobnějšími informacemi o omezeních volně dostupné verze. Projekt Repl.it sice ve svém názvu obsahuje zkratku REPL, ovšem ve skutečnosti jsou podporovány nejenom interpretované jazyky se smyčkou REPL, ale i programovací jazyky překládané.
Obrázek 11: Nastavení základních vlastností webového IDE.
V prostředí Repl.it je možné kromě základních věcí (správa projektu, editace zdrojových kódů atd.) používat například i debugger, popř. provést propojení s Gitem (většinou s GitHubem). Ovšem podporovány jsou do jisté míry i jednotkové testy, propojení vyvíjené aplikace s databází a další operace, o nichž se zmíníme v navazujících kapitolách.
Obrázek 12: Vytvoření nového sezení s volbou programovacího jazyka i celého ekosystému.
Celý mechanismus Repl.it je postaven na obrazech operačních systémů, v nichž je vždy nainstalován a otestován jeden z podporovaných programovacích jazyků. Díky tomuto mechanismu je poměrně snadné do Repl.it přidat podporu pro prakticky libovolný další programovací jazyk – postačuje „jen“ vytvořit příslušný obraz, přidat podporu do programátorského editoru, jazyk zaregistrovat, napsat nápovědu atd. V současnosti tak toto webové programátorské prostředí poskytuje několik desítek odzkoušených programovacích jazyků a další se budou postupně přidávat. Ostatně podívejme se na tabulku, v níž jsou podporované jazyky vypsány (jen několik z nich se nachází v beta fázi vývoje, resp. přesněji řečeno nasazení):
| Clojure |
| Haskell |
| Kotlin |
| QBasic |
| Forth |
| LOLCODE |
| BrainF |
| Emoticon |
| Bloop |
| Unlambda |
| CoffeeScript |
| Scheme |
| APL |
| Lua |
| Ruby |
| Roy |
| Python |
| Node.js |
| JavaScript |
| Deno (beta) |
| Golang |
| C++ |
| C |
| C# |
| F# |
| HTML, CSS, JS |
| Rust |
| Swift |
| Python (with Turtle) |
| Basic |
| R |
| Bash |
| Crystal |
| Julia |
| Elixir |
| Nim |
| Dart |
| Reason Node.js |
| Tcl |
| Erlang |
| TypeScript |
| Pygame |
| Love2D |
| Emacs Lisp (Elisp) |
| PHP Web Server |
| SQLite |
| Java |
| PHP CLI |
| Pyxel |
| Raku |
| Scala |
| Nix |
13. Konzole s interpretrem jazyka F# (fsi)
Vzhledem k tomu, že vývojář používající prostředí Repl.it má k dispozici operační systém s interpretrem či překladačem vybraného programovacího jazyka, je po technické stránce jednoduché zajistit přístup do konzole s interpretrem (resp. přesněji řečeno s plnohodnotnou smyčkou REPL – Read Eval Print Loop). To je velmi užitečné i pro jazyk F# a v některých případech tuto konzoli použijeme. Plnohodnotný REPL programovacího jazyka F# otevřeme z konzole zadáním příkazu:
dotnet fsi
kde fsi znamená F# Interactive. Práce v konzoli je jednoduchá a přímočará, jak ukazuje následující příklad:
Obrázek 13: REPL programovacího jazyka F#.
14. Dva základní koncepty, na nichž je jazyk F# postaven: funkce a datové typy
Jazyk F# patří do rodiny funkcionálních programovacích jazyků, jak již to ostatně částečně prozrazuje jeho jméno. A ve funkcionálních programovacích jazycích mají funkce stejně plnohodnotný význam, jako jakékoli jiné hodnoty. V jazyku F# je neanonymní funkce vytvořena stejně jako jakákoli jiná hodnota s využitím klíčového slova let (zatímco u jazyka ML se používalo klíčové slovo fun). Vyzkoušíme si to v REPLu jazyka F# (fsi) na definici funkce pojmenované inc, která bude mít jediný parametr nazvaný x. V těle funkce se vypočte výraz x+1, jehož výsledek je současně i návratovou hodnotou funkce:
> let inc x = x + 1;; val inc: x: int -> int
U této funkce je zajímavé především to, že jsme nikde neuvedli typ parametru ani typ návratové hodnoty a přesto jazyk F# korektně zjistil, že se jedná o funkci int → int (tedy jediným parametrem je celé číslo a návratovou hodnotou je taktéž celé číslo). Přitom se vychází z těla funkce, tedy z výrazu n+1, což je v jazyku F# striktně součet dvou celých čísel.
Obrázek 14: S rostoucí komplexitou kódu roste význam (statického) typování. Typová inference v jazyku F# (a ML i OCaml) navíc do značné míry snižuje „počáteční investice“ do statického typového systému.
Autor obrázku: https://bravenewgeek.com/go-is-unapologetically-flawed-heres-why-we-use-it/
Zavolání takové funkce je REPLu jednoduché:
inc 10;;
fun inc n = n + 1;
V jazyku F# taktéž existuje klíčové slovo fun, ovšem na rozdíl od jazyka ML se používá pro definici anonymních funkcí (známé lambda výrazy):
> fun x -> x + 1;; val it: x: int -> int
Předchozí řádek zapsaný uživatelem (tučné písmo) vytvořil anonymní funkci (bez jména) a navázal ji na speciální symbol it, jenž vždy obsahuje výsledek posledního výrazu. To znamená, že anonymní funkci můžeme zavolat (a ihned poté ztratit odkaz na ni, protože it bude navázán na hodnotu 11:
> it 10;; val it: int = 11
15. Explicitní specifikace typu argumentů funkcí
V případě potřeby je pochopitelně možné explicitně specifikovat typ argumentu či argumentů funkce. Syntaxe je v tomto případě jednoduchá – za jméno argumentu (či argumentů) se zapíše dvojtečka a za ní požadovaný datový typ. Například můžeme specifikovat, že typ argumentu x má být hodnota s plovoucí řádovou čárkou, tedy typ float (a nikoli int získaný typovou inferencí). Syntaxe zápisu bude v tomto případě vypadat následovně:
> let inc2 x:float = x + 1;;
Ovšem jazyk F# nebude spokojený, protože se snažíme o přetypování celočíselného výrazu (tedy výrazu, jehož výsledkem je hodnota typu int) na návratovou hodnotu typu float. Mnoho typových systémů takové automatické převody povoluje (někdy dokonce i oběma směry – hodně štěstí), ale zde tomu tak není:
let inc2 x:float = x + 1;; ---------------------^ /home/runner/DimgrayOutrageousFlashdrive/stdin(13,22): error FS0043: The type 'float' does not match the type 'int'
Jedno z možných řešení (jedná se však o rozumné řešení?) by mohlo vypadat následovně – změníme druhý operand u operandu „+“ tak, aby se jednalo o konstantu typu float a nikoli int. Poté je již vše v pořádku, neboť sčítáme dvě hodnoty typu float:
> let inc2 x:float = x + 1.0;; val inc2: x: float -> float
Nově upravenou funkci si můžeme ihned vyzkoušet:
> inc2 1.0;; val it: float = 2.0
Interpret opět vypíše nejenom hodnotu, ale i její přesný typ (proč je hodnota nazvaná it se dozvíme příště).
using System.Reflection;
using Microsoft.FSharp.Core;
[assembly: FSharpInterfaceDataVersion(2, 0, 0)]
[assembly: AssemblyVersion("0.0.0.0")]
[CompilationMapping(SourceConstructFlags.Module)]
public static class @_
{
public static double inc2(double x)
{
return x + 1.0;
}
}
namespace <StartupCode$_>
{
internal static class $_
{
}
}
16. Obsah druhé části seriálu
Ve druhé části seriálu o programovacím jazyku F# si ukážeme další vlastnosti funkcí, protože právě způsob chápání funkcí je jednou z nejdůležitějších předností tohoto jazyka (kterým se F# a obecně jazyky z rodiny ML odlišují od dalších programovacích jazyků). Taktéž si ukážeme některé další možnosti nabízené typovým systémem jazyka F# a podíváme se i na jednu z jeho nejsilnějších zbraní – pattern matching.
17. Seriál o OCaml – async v praxi?
V osmé kapitole jsme si řekli, že jazyk F# původně vycházel přímo z programovacího jazyka OCaml. Později se sice cesty obou jazyků poněkud rozešly (F# musel lépe kooperovat s prostředím .NET, což si vyžádalo ústupky), ovšem stále mají mnoho společného. A zdá se, že na Rootu je mezi čtenáři poptávka po obou jazycích, takže si vyzkoušejme malý pokus. Vždy po článku o nějaké vlastnosti či vlastnostech programovacího jazyka F# vyjde stručnější článek, který ukáže podobný koncept, ovšem upravený pro OCaml (později budou ovšem články nutně divergovat). Navazující úvodní článek o OCaml bude skutečně stručný (protože vše již bylo řečeno zde :-) – ukážeme si jeho instalaci, nastavení interaktivního prostředí utop atd.
18. Repositář s demonstračními příklady
Všechny výše popsané demonstrační příklady byly uloženy do repositáře dostupného na adrese https://github.com/tisnik/f-sharp-examples/. V tabulce umístěné pod tímto odstavcem jsou uvedeny odkazy na tyto příklady:
| # | Příklad | Popis příkladu | Cesta |
|---|---|---|---|
| 1 | ML/fib_recursive.ml | výpočet hodnoty z Fibonacciho posloupnosti rekurzivně | https://github.com/tisnik/f-sharp-examples/tree/master/ML/fib_recursive.ml |
| 2 | ML/fib_pattern_matching.ml | výpočet hodnoty z Fibonacciho posloupnosti založený na pattern matchingu | https://github.com/tisnik/f-sharp-examples/tree/master/ML/fib_pattern_matching.ml |
| 3 | ML/len_pattern_matching1.ml | výpočet délky seznamu založený na pattern matchingu (první varianta) | https://github.com/tisnik/f-sharp-examples/tree/master/ML/len_pattern_matching1.ml |
| 4 | ML/len_pattern_matching2.ml | výpočet délky seznamu založený na pattern matchingu (zkrácená varianta) | https://github.com/tisnik/f-sharp-examples/tree/master/ML/len_pattern_matching2.ml |
| 5 | OCaml/fib_recursive.ml | výpočet hodnoty z Fibonacciho posloupnosti rekurzivně | https://github.com/tisnik/f-sharp-examples/tree/master/OCaml/fib_recursive.ml |
| 6 | OCaml/fib_tail_recursive.ml | výpočet hodnoty z Fibonacciho posloupnosti s využitím koncové rekurze | https://github.com/tisnik/f-sharp-examples/tree/master/OCaml/fib_tail_recursive.ml |
| 7 | OCaml/fib_pattern_matching.ml | výpočet hodnoty z Fibonacciho posloupnosti založený na pattern matchingu | https://github.com/tisnik/f-sharp-examples/tree/master/OCaml/fib_pattern_matching.ml |
| 8 | OCaml/local_binding.ml | symbol lokální uvnitř funkce | https://github.com/tisnik/f-sharp-examples/tree/master/OCaml/local_binding.ml |
| 9 | article01/function.fs | deklarace pojmenované funkce | https://github.com/tisnik/f-sharp-examples/tree/master/article01/function.fs |
| 10 | article01/lambda.fs | deklarace anonymní funkce | https://github.com/tisnik/f-sharp-examples/tree/master/article01/lambda.fs |
| 11 | article01/local_binding1.fs | lokální symboly ve funkci | https://github.com/tisnik/f-sharp-examples/tree/master/article01/local_binding1.fs |
| 12 | article01/local_binding2.fs | lokální symboly ve funkci | https://github.com/tisnik/f-sharp-examples/tree/master/article01/local_binding2.fs |
| 13 | article01/function_type1.fs | explicitní definice návratového typu funkce (korektní) | https://github.com/tisnik/f-sharp-examples/tree/master/article01/function_type1.fs |
| 14 | article01/function_type2.fs | explicitní definice návratového typu funkce (nekorektní) | https://github.com/tisnik/f-sharp-examples/tree/master/article01/function_type2.fs |
19. Literatura
- Get Programming with F#
https://www.manning.com/books/get-programming-with-f-sharp - F# for Scientists
https://www.amazon.com/F-Scientists-Jon-Harrop-ebook/dp/B005PS97RO - Domain Modeling Made Functional
https://fsharpforfunandprofit.com/books/ - Functional Programming with F# (na Overleaf, tedy i se zdrojovými kódy)
https://www.overleaf.com/project/5bf2cb3cd9568d5a75bfcba9 - Book of F#
https://nostarch.com/fsharp - F# Programming (Wikibook)
https://en.wikibooks.org/wiki/F_Sharp_Programming - Stylish F#: Crafting Elegant Functional Code for .NET and .NET Core
https://www.amazon.com/dp/1484239997/ - ML for the Working Programmer
https://www.cl.cam.ac.uk/~lp15/MLbook/pub-details.html - Elements of ML Programming, 2nd Edition (ML97)
http://infolab.stanford.edu/~ullman/emlp.html - A tour of Standard ML
https://saityi.github.io/sml-tour/tour/welcome - The History of Standard ML
https://smlfamily.github.io/history/SML-history.pdf - The Standard ML Basis Library
https://smlfamily.github.io/Basis/ - Programming in Standard ML
http://www.cs.cmu.edu/~rwh/isml/book.pdf - Programming in Standard ML '97: A Tutorial Introduction
http://www.lfcs.inf.ed.ac.uk/reports/97/ECS-LFCS-97–364/ - Programming in Standard ML '97: An On-line Tutorial
https://homepages.inf.ed.ac.uk/stg/NOTES/ - The OCaml system release 4.13
https://ocaml.org/releases/4.13/htmlman/index.html - Real World OCaml: Functional programming for the masses
https://dev.realworldocaml.org/ - OCaml from the Very Beginning
http://ocaml-book.com/ - OCaml from the Very Beginning: More OCaml : Algorithms, Methods & Diversions
http://ocaml-book.com/more-ocaml-algorithms-methods-diversions/ - Unix system programming in OCaml
http://ocaml.github.io/ocamlunix/ - OCaml for Scientists
https://www.ffconsultancy.com/products/ocaml_for_scientists/index.html - Using, Understanding, and Unraveling The OCaml Language
https://caml.inria.fr/pub/docs/u3-ocaml/ - Developing Applications With objective Caml
https://caml.inria.fr/pub/docs/oreilly-book/index.html - Introduction to Objective Caml
http://courses.cms.caltech.edu/cs134/cs134b/book.pdf - How to Think Like a (Functional) Programmer
https://greenteapress.com/thinkocaml/index.html
20. Odkazy na Internetu
- General-Purpose, Industrial-Strength, Expressive, and Safe
https://ocaml.org/ - OCaml playground
https://ocaml.org/play - Online Ocaml Compiler IDE
https://www.jdoodle.com/compile-ocaml-online/ - Get Started – OCaml
https://www.ocaml.org/docs - Get Up and Running With OCaml
https://www.ocaml.org/docs/up-and-running - Better OCaml (Online prostředí)
https://betterocaml.ml/?version=4.14.0 - OCaml file extensions
https://blog.waleedkhan.name/ocaml-file-extensions/ - First thoughts on Rust vs OCaml
https://blog.darklang.com/first-thoughts-on-rust-vs-ocaml/ - Standard ML of New Jersey
https://www.smlnj.org/ - Programming Languages: Standard ML – 1 (a navazující videa)
https://www.youtube.com/watch?v=2sqjUWGGzTo - 6 Excellent Free Books to Learn Standard ML
https://www.linuxlinks.com/excellent-free-books-learn-standard-ml/ - SOSML: The Online Interpreter for Standard ML
https://sosml.org/ - ML (Computer program language)
https://www.barnesandnoble.com/b/books/other-programming-languages/ml-computer-program-language/_/N-29Z8q8Zvy7 - Strong Typing
https://perl.plover.com/yak/typing/notes.html - What to know before debating type systems
http://blogs.perl.org/users/ovid/2010/08/what-to-know-before-debating-type-systems.html - Types, and Why You Should Care (Youtube)
https://www.youtube.com/watch?v=0arFPIQatCU - DynamicTyping (Martin Fowler)
https://www.martinfowler.com/bliki/DynamicTyping.html - DomainSpecificLanguage (Martin Fowler)
https://www.martinfowler.com/bliki/DomainSpecificLanguage.html - Language Workbenches: The Killer-App for Domain Specific Languages?
https://www.martinfowler.com/articles/languageWorkbench.html - Effective ML (Youtube)
https://www.youtube.com/watch?v=-J8YyfrSwTk - Why OCaml (Youtube)
https://www.youtube.com/watch?v=v1CmGbOGb2I - CSE 341: Functions and patterns
https://courses.cs.washington.edu/courses/cse341/04wi/lectures/03-ml-functions.html - Comparing Objective Caml and Standard ML
http://adam.chlipala.net/mlcomp/ - What are the key differences between Standard ML and OCaml?
https://www.quora.com/What-are-the-key-differences-between-Standard-ML-and-OCaml?share=1 - Cheat Sheets (pro OCaml)
https://www.ocaml.org/docs/cheat_sheets.html - Syllabus (FAS CS51)
https://cs51.io/college/syllabus/ - Abstraction and Design In Computation
http://book.cs51.io/ - Learn X in Y minutes Where X=Standard ML
https://learnxinyminutes.com/docs/standard-ml/ - CSE307 Online – Summer 2018: Principles of Programing Languages course
https://www3.cs.stonybrook.edu/~pfodor/courses/summer/cse307.html - CSE307 Principles of Programming Languages course: SML part 1
https://www.youtube.com/watch?v=p1n0_PsM6hw - CSE 307 – Principles of Programming Languages – SML
https://www3.cs.stonybrook.edu/~pfodor/courses/summer/CSE307/L01_SML.pdf - SML, Some Basic Examples
https://cs.fit.edu/~ryan/sml/intro.html - History of programming languages
https://devskiller.com/history-of-programming-languages/ - History of programming languages (Wikipedia)
https://en.wikipedia.org/wiki/History_of_programming_languages - Jemný úvod do rozsáhlého světa jazyků LISP a Scheme
https://www.root.cz/clanky/jemny-uvod-do-rozsahleho-sveta-jazyku-lisp-a-scheme/ - The Evolution Of Programming Languages
https://www.i-programmer.info/news/98-languages/8809-the-evolution-of-programming-languages.html - Evoluce programovacích jazyků
https://ccrma.stanford.edu/courses/250a-fall-2005/docs/ComputerLanguagesChart.png - Poly/ML Homepage
https://polyml.org/ - PolyConf 16: A brief history of F# / Rachel Reese
https://www.youtube.com/watch?v=cbDjpi727aY - Programovací jazyk Clojure 18: základní techniky optimalizace aplikací
https://www.root.cz/clanky/programovaci-jazyk-clojure-18-zakladni-techniky-optimalizace-aplikaci/ - Moscow ML Language Overview
https://itu.dk/people/sestoft/mosml/mosmlref.pdf - ForLoops
http://mlton.org/ForLoops - Funkcionální dobrodružství v JavaScriptu
https://blog.kolman.cz/2015/12/funkcionalni-dobrodruzstvi-v-javascriptu.html - Recenze knihy Functional Thinking (Paradigm over syntax)
https://www.root.cz/clanky/recenze-knihy-functional-thinking-paradigm-over-syntax/ - Currying
https://sw-samuraj.cz/2011/02/currying/ - Používání funkcí v F#
https://docs.microsoft.com/cs-cz/dotnet/fsharp/tutorials/using-functions - Funkce vyššího řádu
http://naucte-se.haskell.cz/funkce-vyssiho-radu - Currying (Wikipedia)
https://en.wikipedia.org/wiki/Currying - Currying (Haskell wiki)
https://wiki.haskell.org/Currying - Haskell Curry
https://en.wikipedia.org/wiki/Haskell_Curry - Moses Schönfinkel
https://en.wikipedia.org/wiki/Moses_Sch%C3%B6nfinkel - .NET framework
https://dotnet.microsoft.com/en-us/ - F# – .NET Blog
https://devblogs.microsoft.com/dotnet/category/fsharp/ - Playground: OCaml
https://ocaml.org/play - The F# Survival Guide
https://web.archive.org/web/20110715231625/http://www.ctocorner.com/fsharp/book/default.aspx - Object-Oriented Programming — The Trillion Dollar Disaster
https://betterprogramming.pub/object-oriented-programming-the-trillion-dollar-disaster-92a4b666c7c7 - Goodbye, Object Oriented Programming
https://cscalfani.medium.com/goodbye-object-oriented-programming-a59cda4c0e53 - 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 - 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 - 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 - 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 - 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 - 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 - Why Programmers Need Limits
https://cscalfani.medium.com/why-programmers-need-limits-3d96e1a0a6db - Signatures
https://learn.microsoft.com/en-us/dotnet/fsharp/language-reference/signature-files - F# for Linux People
https://carpenoctem.dev/blog/fsharp-for-linux-people/ - Ionide project
https://ionide.io/ - FsAutoComplete
https://ionide.io/Tools/fsac.html - Interactive (.NET for Jupyter Notebook)
https://github.com/dotnet/interactive/#jupyter-and-nteract - let Bindings
https://github.com/dotnet/docs/blob/main/docs/fsharp/language-reference/functions/let-bindings.md - Lambda Expressions: The fun Keyword (F#)
https://github.com/dotnet/docs/blob/main/docs/fsharp/language-reference/functions/lambda-expressions-the-fun-keyword.md - Infographic showing code complexity vs developer experience
https://twitter.com/rossipedia/status/1580639227313676288 - OCaml for the Masses: Why the next language you learn should be functional
https://queue.acm.org/detail.cfm?id=2038036 - Try EIO
https://patricoferris.github.io/try-eio/ - Try OCaml
https://try.ocaml.pro/ - ML – funkcionální jazyk s revolučním typovým systémem
https://www.root.cz/clanky/ml-funkcionalni-jazyk-s-revolucnim-typovym-systemem/ - Funkce a typový systém programovacího jazyka ML
https://www.root.cz/clanky/funkce-a-typovy-system-programovaciho-jazyka-ml/ - 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/ - Operátor J (Wikipedia)
https://en.wikipedia.org/wiki/J_operator - Standard ML (Wikipedia)
https://en.wikipedia.org/wiki/Standard_ML - Don Syme
https://en.wikipedia.org/wiki/Don_Syme - Python to OCaml: Retrospective
http://roscidus.com/blog/blog/2014/06/06/python-to-ocaml-retrospective/ - Xavier Leroy
https://en.wikipedia.org/wiki/Xavier_Leroy
