Hlavní navigace

Moonscript: jazyk inspirovaný CoffeeScriptem určený pro ekosystém jazyka Lua

9. 11. 2021
Doba čtení: 31 minut

Sdílet

 Autor: Depositphotos
Seznámíme se s jazykem nazvaným Moonscript. Syntaxe a především sémantika tohoto jazyka je inspirovaná CoffeeScriptem, ovšem Moonscript je určen pro ekosystém jazyka Lua a je tak použitelný i pro tvorbu aplikací pro mikrořadiče.

Obsah

1. Moonscript: jazyk inspirovaný CoffeeScriptem určený pro ekosystém jazyka Lua

2. Svět transpřekladačů

3. Příklad podobného transpřekladače pro odlišný ekosystém: Coconut

4. Instalace Moonscriptu

5. Tradiční začátek – „Hello, world!“ v Moonscriptu i v jazyce Lua

6. Lokální proměnné

7. Interpolace řetězců

8. Víceřádkové řetězce

9. Nové operátory

10. Kombinace aritmetické, logické i řetězcové operace s přiřazením

11. Modifikovaná syntaxe volání funkcí

12. Definice nových funkcí operátorem ->

13. Prázdná funkce bez parametrů

14. Funkce s tělem, ovšem bez parametrů

15. Návratová hodnota funkce

16. Definice funkce s parametry

17. Návrat většího množství hodnot z funkce

18. Parametry funkce s implicitní hodnotou

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

20. Odkazy na Internetu

1. Moonscript: jazyk inspirovaný CoffeeScriptem určený pro ekosystém jazyka Lua

„The syntax of MoonScript has been heavily inspired by the syntax of CoffeeScript. MoonScript is CoffeeScript for Lua.“

S programovacím jazykem Lua jsme se již na stránkách tohoto serveru setkali, a to dokonce již mnohokrát. Většina článků o tomto jazyku je shrnuta do seriálu Programovací jazyk Lua a taktéž jsme se Luou zabývali ve druhém seriálu nazvaném Torch: framework pro strojové učení. Víme již, že se tento programovací jazyk stal oblíbený například mezi tvůrci her, v nichž je použit pro skriptování. To ovšem není zdaleka vše, protože Lua je použita například v systému LuaTeX, v databázi Redis, ve webovém serveru Nginx a v neposlední řadě i v textovém editoru Neovim. Jednoduše použitelná syntaxe a současně i poměrně velká vyjadřovací schopnost jazyka Lua by však pravděpodobně nedostačovala pro jeho masovější rozšíření, a to zejména v situaci, kdy tuto niku programovacích jazyků do značné míry okupuje Python, kterému se již úspěšně podařilo „odstavit“ některé konkurenty.

Zajímavé je i použití jazyka Lua v oblasti mikrořadičů, kam se tento jazyk (podle mého názoru) hodí lépe, než výše zmíněný Python, resp. jeho varianta nazvaná MicroPython. Ovšem některé syntaktické konstrukce jazyka Lua (a ještě ve větší míře sémantika) by si zasloužily vylepšení. Samotná Lua je velmi stabilním jazykem, který se příliš nevyvíjí, takže tvůrci různých rozšíření jsou postaveni před úkol zachování kompatibility s celým ekosystémem (tedy s interpretrem Lua i s LuaJITem). Podobný problém řeší tvůrci nových jazyků pro webové prohlížeče, protože i zde byl (až do relativně nedávné doby) podporován jediný jazyk – JavaScript. Řešením jsou transpřekladače (transpilery), které zdrojový kód napsaný v jednom jazyku převedou do jazyku jiného, v našich příkladech buď do jazyka Lua nebo do JavaScriptu. A právě takovým způsobem je implementován programovací jazyk Moonscript, který je inspirován CoffeeScriptem (ovšem i tvůrci ES6 se nechali CoffeeScriptem ovlivnit, což ostatně sami potvrzují). Na Moonscript se můžeme dívat jako na jakýsi hybrid mezi Pythonem, jazykem Lua a jazykem Ruby.

Poznámka: na tomto místě je vhodné poznamenat, že největší popularity dosáhl CoffeeScript přibližně v roce 2010. Poté – společně s rozšiřováním možností samotného JavaScriptu inspirovaného mj. i CoffeeScriptem – začala jeho popularita klesat a dnes je sice stále používán, ale JavaScript v žádném případě nenahradil (ostatně se to nepodařilo ani projektu Dart). V případě dvojice Lua + Moonscript je ovšem situace odlišná, neboť samotný jazyk Lua je již velmi stabilní, což je ostatně považováno za jednu z jeho velmi dobrých vlastností.

Moonscript přináší mnoho zajímavých prvků, například:

  1. Jednodušší deklaraci lokálních proměnných
  2. Interpolaci řetězců
  3. Podporu pro víceřádkové řetězce
  4. Deklaraci funkcí operátorem „šipky“
  5. Deklaraci metod operátorem „tlusté šipky“
  6. Deklarace funkcí s implicitní hodnotou parametrů
  7. Rozšíření tabulky operátorů
  8. Prakticky každý příkaz je současně i výrazem vracejícím hodnotu (smyčky, podmínky)
  9. Generátorová notace seznamu (list comprehensions)
  10. Generátorová notace tabulky (table comprehensions)
  11. Vylepšený slicing
  12. Deklarace tříd
  13. Deklarace třídních proměnných
  14. Podpora pro anonymní třídy
  15. atd.
Poznámka: v dnešním článku si ukážeme pouze vybrané vlastnosti Moonscriptu, které ukazují, jak lze relativně snadno rozšířit jazyk Lua o „syntaktický cukr“ – nové operátory, nový způsob deklarace funkcí, interpolaci řetězců atd.

2. Svět transpřekladačů

Problematikou takzvaných transpřekladačů (anglicky transcompilers nebo taktéž source-to-source compilers) jsme se již na stránkách Rootu zabývali, a to dokonce několikrát. Připomeňme si například projekty ClojureScript (což je transpřekladač Clojure → JavaScript), popř. projekty lua2js (transpřekladač Lua → opět JavaScript) a Wisp (programovací jazyk podobný Clojure transpřekládaný opět do JavaScriptu). V předchozích větách byl použit výraz „transpřekladač“, takže si ho ve stručnosti vysvětlíme. Transpřekladače jsou nástroje sloužící pro překlad algoritmů zapsaných v nějakém zdrojovém programovacím jazyce do zvoleného cílového programovacího jazyka (ovšem nikoli do nativního kódu či bajtkódu, to je totiž role běžných překladačů).

Transpřekladače se v informatice používají již po několik desetiletí; například se stále můžeme setkat s nástroji, které převádí kód z nějakého vyššího programovacího jazyka do Céčka, které je v současnosti s trochou nadsázky chápáno jako „univerzální assembler“. Asi nejznámějším příkladem z této oblasti je nástroj nazvaný web2c, jenž slouží pro transformaci zdrojových kódů TeXu do céčka. Transpřekladače byly – a to zejména v minulém desetiletí, konkrétně před příchodem ES6 – velmi populární i mezi programátory webových aplikací, a to zejména z toho důvodu, že webové prohlížeče nativně podporují většinou pouze JavaScript, který je tak přirozeně cílovým jazykem transpřekladačů (proto se mu také někdy říká „assembler pro web“, viz též odkazy na konci článku). Určitou revolucí byl v této oblasti právě CoffeeScript, ke kterému se dnes ještě několikrát vrátíme. A mnoho vlastností CoffeeScriptu bylo převzato do ES6 (ECMAScript 2015), což způsobilo postupný odklon od CoffeeScriptu.

Z praxe můžeme uvést například následující projekty založené na transpřekladači:

# Jazyk či transpřekladač Poznámka
1 CoffeeScript přidání syntaktického cukru do JavaScriptu, dnes popisovaný Moonscript je jím inspirován
2 ClojureScript překlad aplikací psaných v jazyce Clojure do JavaScriptu
3 TypeScript nadmnožina jazyka JavaScript, přidání datových typů
4 6to5 transpřeklad z ECMAScript 6 (v roce 2015 nová varianta JavaScriptu) do starší varianty JavaScriptu
5 Kaffeine rozšíření JavaScriptu (opět!) o nové vlastnosti
6 RedScript programovací jazyk inspirovaný Ruby
7 GorillaScript další rozšíření JavaScriptu (JavaScript evidentně potřeboval různá rozšíření :-)
8 ghcjs transpřekladač pro fanoušky programovacího jazyka Haskell
9 Haxe transpřekladač, mezi jehož cílové jazyky patří i Java a JavaScript
10 Wisp transpřekladač jazyka podobného Clojure, opět do JavaScriptu
11 ScriptSharp transpřekladač z C# do JavaScriptu
12 Dart transpřekladač z jazyka Dart do JavaScriptu
13 COBOL → C transpřekladač OpenCOBOL
14 COBOL → Java transpřekladač P3COBOL
15 lua2js transpřekladač jazyka Lua, opět do JavaScriptu
16 Coconut transpřekladač do Pythonu
17 Moonscript transpřekladač do jazyka Lua, jímž se budeme zabývat dnes
Poznámka: z předchozího seznamu je zřejmé, že transpřekladače byly či stále jsou používány v prostředí, které podporuje pouze jediný cílový jazyk, což byl před příchodem technologie WASM případ webových prohlížečů.

3. Příklad podobného transpřekladače pro odlišný ekosystém: Coconut

Jeden zajímavý a přitom s dnešním tématem velmi dobře korespondující tranpřekladač se jmenuje Coconut. Ten je navržen takovým způsobem, aby byl zpětně kompatibilní s Pythonem. To znamená, že skript napsaný v Pythonu je současně i skriptem napsaným v jazyku Coconut (což je zajímavé, protože do Coconutu byla přidána tři nová klíčová slova data, match a case, jejichž význam se však rozlišuje z kontextu). Coconut je tak možné považovat za sémantické i syntaktické rozšíření Pythonu, přičemž se autor tohoto jazyka zaměřil především na funkcionální rysy (funkce vyššího řádu, neměnitelné hodnoty, podpora pro tvorbu kolon a kompozic funkcí atd.) a taktéž do Coconutu přidal podporu pro pattern matching (inspiraci získal zde). Coconut může pracovat jako interpret s interaktivní smyčkou REPL či jako transpřekladač (transcompiler, transpiler) do jazyka Python, takže je možné použít celý pythonovský ekosystém. Přesnější informace o tom, se kterými verzemi Pythonu je Coconut kompatibilní, naleznete na adrese http://coconut.readthedoc­s.io/en/master/DOCS.html#com­patible-python-versions.

Vzhledem k tomu, že je programovací jazyk Coconut implementován jako transpřekladač a současně se jedná o jazyk tvořící nadmnožinu Pythonu, je v něm možné použít prakticky všechny knihovny pythonovského ekosystému, což platí zejména pro CPython a PyPy, i když větší problémy nelze předpokládat ani v případě použití Jythonu či IronPythonu. Navíc je pro všechny programátory znající Python vlastně velmi jednoduché přejít na Coconut – stále je totiž možné využít stávající syntaxi a sémantiku Pythonu a rozšíření přidaná Coconutem použít jen v těch místech, kde to má v daný okamžik význam. To je zásadní rozdíl od některých jiných (nejenom funkcionálních) jazyků, s nimiž se programátor může setkat a které mnohdy vyžadují, aby se začal učit jak nový programovací jazyk, tak i jeho ekosystém (který je navíc u nově vznikajících jazyků zpočátku malý, navíc může být spousta knihoven dostupných jen v alfa verzích).

Poznámka: tato potenciálně velmi užitečná a praktická vlastnost ovšem neplatí pro Moonscript a jeho vztah k jazyku Lua.

Použití transpřekladače však přináší i některé nevýhody, které se projeví například ve chvíli, kdy v programu vznikne chyba či nezachycená výjimka. V takovém případě totiž získáme stack trace platný pro výsledný pythonovský program, nikoli pro uživatelem vytvořený kód. V některých prostředích lze tomuto negativnímu jevu zabránit použitím technologie source map, což jsou (zjednodušeně řečeno) soubory s mapováním mezi řádkem+příkazem v transpilovaném kódu a řádkem+příkazem v originálním zdrojovém kódu (v tomto případě je i minifikace považována za jednu z forem transpilace).

Poznámka: source mapy však nejsou v dále popsaném Moonscriptu podporovány, stejně jako nejsou podporovány v celém ekosystému jazyka Lua.

4. Instalace Moonscriptu

Po krátké odbočce do ekosystému programovacího jazyka Python a transpřekladačů do tohoto dnes velmi populárního programovacího jazyka se vraťme k projektu Moonscript. Popíšeme si totiž instalaci Moonscriptu, a to jak s využitím distribuce ULua, tak i s využitím správce balíčků nazvaného LuaRocks.

Pokud máte nainstalován nástroj ULua, je instalace Moonscriptu snadná. Nejdříve se přesvědčíme, že daný balíček vůbec existuje:

$ cd ulua/bin
 
$ ./upkg available |grep moonscript
 
+ crescent        | crescent : a command-line program for moonscript - with pretty colors!  | 0.3.0-103, 0.2.0-103, 0.1.1-103
+ moon            | moonscript : A programmer friendly language that compiles to Lua        | 0.5.0-103, 0.4.0-103, 0.3.2-103
+ moongrahams     | moongrahams :  lua/moonscript library for performing bayesian analysis  | 0.0-103
+ moonpick        | moonpick : An alternative moonscript linter.                            | 0.8-103, 0.6-103
+ moonscript      | moonscript : A programmer friendly language that compiles to Lua        | 0.5.0-103, 0.4.0-103, 0.3.2-103
+ placeholder     | moon-watch : better -watch for moonscript(moonc) for MacOS              | 0.2-203

Zobrazit si můžeme i podrobnější informace o nalezeném balíčku moonscript:

$ ./upkg available moonscript
 
Module information:
name        : moonscript
version     : 0.5.0-103
require     : alt_getopt~0.7, lfs~1.5, lpeg~0.10, luajit~2.0, moon~0.5.0-103, re~0.10
description : moonscript : A programmer friendly language that compiles to Lua
homepage    : http://moonscript.org
license     : MIT

Ve třetím kroku provedeme instalaci balíčku moonscript i všech dalších potřebných balíčků, což je zejména balíček lpeg s podporou regulárních výrazů:

$ ./upkg add moonscript
 
Installing matching module and its requirements:
+ alt_getopt | alt-getopt : Process application arguments the same way as getopt_long | 0.8.0-103
+ lpeg       | lpeg : Parsing Expression Grammars For Lua                             | 0.12.2-103
+ moon       | moonscript : A programmer friendly language that compiles to Lua       | 0.5.0-103
+ moonscript | moonscript : A programmer friendly language that compiles to Lua       | 0.5.0-103
+ re         | lpeg : Parsing Expression Grammars For Lua                             | 0.12.2-103
Confirm (y/n)?
 
Downloading:
+ /pkg/alt_getopt/0.8.0-103 | 100% of 4KB
+ /pkg/moon/0.5.0-103       | 100% of 14KB
+ /pkg/re/0.12.2-103        | 100% of 2KB
+ /pkg/lpeg/0.12.2-103      | 100% of 133KB
+ /pkg/moonscript/0.5.0-103 | 100% of 58KB
Done

Po provedení předchozích kroků by se mělo v adresáři ~/ulua/bin/ objevit několik nových spustitelných souborů:

$ ls -1
 
moon
moonc
moonc.cmd
moon.cmd
scilua
scilua.cmd
upkg
upkg.cmd

A obsah adresáře ~/ulua se změní následovně:

.
├── alt_getopt
│   └── 0_8_0+103
├── bin
├── clib_libcurl
│   └── 7_42_1+3
├── clib_libopenblas
│   └── 0_2_15
├── cURL
│   └── 0_3_1+103
├── host
│   ├── init
│   ├── pkg
│   └── tmp
├── lcurl
│   └── 0_3_1+103
├── lfs
│   └── 1_6_3+203
├── lpeg
│   └── 0_12_2+103
├── luajit
│   └── 2_1_head20151128
├── moon
│   └── 0_5_0+103
├── moonscript
│   └── 0_5_0+103
├── pkg
│   └── 1_0_beta10
├── re
│   └── 0_12_2+103
├── sci
│   └── 1_0_beta12
├── sci-lang
│   └── 1_0_beta10
├── serpent
│   └── 0_28+103
└── xsys
    └── 1_0_2

Alternativně je možné pro instalaci použít správce balíčků luarocks, a to následovně:

$ luarocks install moonscript

V obou případech by měl být k dispozici příkaz moon a moonc:

$ ./moon -v
 
MoonScript version 0.5.0
 
$ ./moon --help
Usage: /home/ptisnovs/ulua/bin/../moonscript/0_5_0+103/__bin/moon [options] [script [args]]

    -h          Print this message
    -d          Disable stack trace rewriting
    -c          Collect and print code coverage
    -v          Print version
$ ./moonc --help
 
Usage: /home/ptisnovs/ulua/bin/../moonscript/0_5_0+103/__bin/moonc [options] files...
 
    -h          Print this message
    -w          Watch file/directory
    -t path     Specify where to place compiled files
    -o file     Write output to file
    -p          Write output to standard out
    -T          Write parse tree instead of code (to stdout)
    -X          Write line rewrite map instead of code (to stdout)
    -l          Perform lint on the file instead of compiling
    -b          Dump parse and compile time (doesn't write output)
    -v          Print version
 
    --          Read from standard in, print to standard out
                (Must be first and only argument)
Poznámka: užitečný je zejména přepínač -w, který umožňuje hlídat změny ve zdrojových souborech ve zvoleném adresáři s tím, že tyto soubory budou okamžitě transpřekládány z Moonscriptu do jazyka Lua.

5. Tradiční začátek – „Hello, world!“ v Moonscriptu i v jazyce Lua

V programovacím jazyce Lua lze program či skript typu „Hello, world!“ napsat následovně:

--
-- Skript zapsaný v jazyce Lua
--
 
print("Hello, world!")

Ve skutečnosti je možné při volání funkce mající pouze jediný parametr typu řetězec, popř. tabulka použít při volání funkce zápis bez kulatých závorek, tedy takto:

--
-- Skript zapsaný v jazyce Lua
--
 
print "Hello, world!"

Přesně takovým způsobem se zapisuje volání funkce i v Moonscriptu, a to i pro funkce s větším počtem parametrů, popř. parametrů jiného typu než jen řetězec a tabulka:

--
-- Skript zapsaný v jazyce Moonscript
--
 
print "Hello, world!"

Překlad předchozího skriptu do jazyka Lua nástrojem moonc by měl vytvořit tento zdrojový soubor plně kompatibilní s jazykem Lua:

--
-- Skript transpilovaný do jazyka Lua
--
 
return print("Hello, world!")
Poznámka: důvodem, proč je volání funkce umístěno do konstrukce return, se budeme zabývat v navazujícím textu.

6. Lokální proměnné

Jedním z méně šťastných rozhodnutí při návrhu programovacího jazyka Lua bylo, že (automaticky) nově vytvářené proměnné jsou globální, nikoli lokální (jak je tomu například v Pythonu). To například znamená, že následující skript vypíše hodnotu 42, protože proměnná x byla ve funkci definována jako globální:

function foo()
    x = 42
end
 
foo()
print(x)

V Moonscriptu se před (automaticky) vytvářené proměnné po transpřekladu přidává klíčové slovo local, takže proměnná je vytvořena jako lokální v rámci aktuálního bloku (typicky funkce):

--
-- Skript zapsaný v jazyce Moonscript
--
 
message = "Hello, world!"
 
print message

Výsledek transpřekladu:

--
-- Skript transpilovaný do jazyka Lua
--
 
local message = "Hello, world!"
return print(message)

Samozřejmě ovšem není klíčové slovo local přidáváno před každý přiřazovací výraz, ale pouze při prvním přiřazení:

--
-- Skript zapsaný v jazyce Moonscript
--
 
message = nil
message = "Hello, world!"
 
print message

Výsledek transpřekladu tohoto demonstračního skriptu:

--
-- Skript transpilovaný do jazyka Lua
--
 
local message = nil
message = "Hello, world!"
return print(message)

V případě, že se neprovádí přiřazení, ale pouze čtení proměnné, vrátí se v obou jazycích hodnota nil:

--
-- Skript zapsaný v jazyce Moonscript
--
 
print message

Výsledek:

--
-- Skript transpilovaný do jazyka Lua
--
 
return print(message)

7. Interpolace řetězců

Velmi užitečným rozšířením CoffeeScriptu a jím inspirovaného Moonscriptu je podpora pro takzvanou interpolaci řetězců. Jedná se o mechanismus, který vývojářům umožňuje psát do řetězce výrazy, které jsou vyhodnoceny, převedeny na řetězec a vloženy do generovaného řetězce. Tyto výrazy se zapisují mezi znaky #{ a }. Alternativní zápis klasického programu typu „Hello, world!“ založený na interpolaci řetězců tedy může vypadat například takto:

--
-- Skript zapsaný v jazyce Moonscript
--
 
a = "Hello"
b = "world"
 
print "#{a}, #{b}!"

Programovací jazyk Lua interpolaci řetězců neumožňuje a proto bylo nutné předchozí skript transpřeložit tímto způsobem:

--
-- Skript transpilovaný do jazyka Lua
--
 
local a = "Hello"
local b = "world"
return print(tostring(a) .. ", " .. tostring(b) .. "!")

Mezi znaky #{ a } může být zapsán i složitější výraz:

--
-- Skript zapsaný v jazyce Moonscript
--
 
x = 6
y = 7
 
print "#{x} * #{y} = #{x*y}"

Transformace do jazyka Lua:

--
-- Skript transpilovaný do jazyka Lua
--
 
local x = 6
local y = 7
return print(tostring(x) .. " * " .. tostring(y) .. " = " .. tostring(x * y))

Interpolaci řetězců lze snadno zakázat, a to konkrétně použitím apostrofů namísto uvozovek při zápisu řetězce:

--
-- Skript zapsaný v jazyce Moonscript
--
 
x = 6
y = 7
 
print '#{x} * #{y} = #{x*y}'

Transformace do jazyka Lua nyní interpolaci řetězců nepoužívá:

--
-- Skript transpilovaný do jazyka Lua
--
 
local x = 6
local y = 7
return print('#{x} * #{y} = #{x*y}')
Poznámka: jak uvidíme dále, je v Moonscriptu naprostá většina programových konstrukcí považována za výraz, což se mj. týká i rozhodovacích konstrukcí typu if-then-else.

8. Víceřádkové řetězce

Moonscriptu jsou, ostatně naprosto stejně jako v CoffeeScriptu, podporovány víceřádkové řetězce. Ty se přitom zapisují tím nejjednodušším možným způsobem – pokud řetězec na řádku nekončí uvozovkami (nebo apostrofem), jsou odpovídající koncové uvozovky hledány na dalších řádcích. Není tedy nutné mít speciální syntaktická pravidla pro jednořádkové a víceřádkové řetězce. Podívejme se nyní na jednoduchý demonstrační příklad s běžným testovacím „dokumentem“ Lorem ipsum:

--
-- Skript zapsaný v jazyce Moonscript
--
 
message = "Lorem ipsum dolor sit amet,
consectetur adipiscing elit, sed do
eiusmod tempor incididunt ut labore et
dolore magna aliqua. Ut enim ad minim
veniam, quis nostrud exercitation ullamco
laboris nisi ut aliquip ex ea commodo
consequat."
 
print message

Tento skript se převede do jazyka Lua takovým způsobem, že se řetězec zapsaný na více řádků převede na jednořádkový řetězec, v němž se ovšem explicitně použijí řídicí znaky \n (což je pochopitelně mnohem méně čitelné, než původní skript):

--
-- Skript transpilovaný do jazyka Lua
--
 
local message = "Lorem ipsum dolor sit amet,\nconsectetur adipiscing elit, sed do\neiusmod tempor incididunt ut labore et\ndolore magna aliqua. Ut enim ad minim\nveniam, quis nostrud exercitation ullamco\nlaboris nisi ut aliquip ex ea commodo\nconsequat."
return print(message)
Poznámka: příkladem může být generování HTML stránky, pokud se ovšem nepoužije nějaký šablonovací systém.

9. Nové operátory

Původní programovací jazyk Lua nabízí programátorům následující sadu operátorů, které se používají při zápisu aritmetických výrazů, logických výrazů, relačních výrazů, popř. pro práci s řetězci:

Priorita Kategorie Operátor Asociativita
1 unární not # – zprava doleva
2 konkatenace .. zprava doleva
3 multiplikativní * / % zleva doprava
4 aditivní + – zleva doprava
5 relační < > <= > zleva doprava
6 test na rovnost/nerovnost == ~= zleva doprava
7 logický součin and zleva doprava
I logický součet or zleva doprava
Poznámka: do výše uvedené tabulky ještě můžeme přidat operátor pro umocnění, který však vyžaduje slinkování se standardní céčkovou matematickou knihovnou a proto nemusí být dostupný ve všech prostředích – typicky ho nenajdeme na mikrořadičích.

V jazyce Moonscript je počet operátorů zvýšen. Prvním (staro)novým operátorem je operátor !=, který má stejný význam jako standardní operátor ~= – jedná se tedy o test na nerovnost dvou hodnot. Důvodem pro přidání operátoru != je pochopitelně lepší srozumitelnost pro programátory znalé některého jazyka z céčkové vývojové větve programovacích jazyků.

Funkci nového operátoru si můžeme snadno ověřit například na tomto skriptu:

--
-- Skript zapsaný v jazyce Moonscript
--
 
x = 1
y = 2
 
print x==2
print x!=2
print x~=2

Kód transpilovaný do jazyka Lua ukazuje, že != je skutečně převeden na operátor ~=:

--
-- Skript transpilovaný do jazyka Lua
--
 
local x = 1
local y = 2
print(x == 2)
print(x ~= 2)
return print(x ~= 2)

10. Kombinace aritmetické, logické i řetězcové operace s přiřazením

S operátorem přiřazení, který se zapisuje jediným znakem =, jsme se již setkali, takže jen pro úplnost:

--
-- Skript zapsaný v jazyce Moonscript
--
 
a = 10
b = "foo"
c = {1,2,3}
 
print a
print b
print c

Korespondující kód v jazyku Lua:

--
-- Skript transpilovaný do jazyka Lua
--
 
local a = 10
local b = "foo"
local c = {
  1,
  2,
  3
}
print(a)
print(b)
return print(c)

Tento operátor byl rozšířen o možnost provést přiřazení společně s další aritmetickou, logickou či řetězcovou operací, a to za předpokladu, že je použita stejná proměnná jak na levé straně, tak i na pravé straně původního výrazu. To znamená, že výraz:

x = x ⊕ y

lze zapsat i formou:

x ⊕= y

a to pro jakýkoli binární operátor zmíněný v předchozí kapitole.

Poznámka: znak ⊕ zde nahrazuje skutečný operátor.

Podívejme se nyní na kombinaci přiřazení s aritmetickou operací:

--
-- Skript zapsaný v jazyce Moonscript
--
 
a = 10
b = 20
c = 30
 
a += 10
b /= 2
c %= 7
 
print a
print b
print c

Převod do jazyka Lua:

--
-- Skript transpilovaný do jazyka Lua
--
 
local a = 10
local b = 20
local c = 30
a = a + 10
b = b / 2
c = c % 7
print(a)
print(b)
return print(c)

Přiřazení lze zkombinovat i s operací pro konkatenaci řetězců:

--
-- Skript zapsaný v jazyce Moonscript
--
 
msg = "Hello, "
msg ..= "world"
msg ..= "!"
 
print msg

Převod do jazyka Lua:

--
-- Skript transpilovaný do jazyka Lua
--
 
local msg = "Hello, "
msg = msg .. "world"
msg = msg .. "!"
return print(msg)

A konečně je možné přiřazení zkombinovat s logickými operátory:

--
-- Skript zapsaný v jazyce Moonscript
--
 
x = true
y = false
 
print x
print y
 
x and= y
y or= true
 
print x
print y

Převod do jazyka Lua:

--
-- Skript transpilovaný do jazyka Lua
--
 
local x = true
local y = false
print(x)
print(y)
x = x and y
y = y or true
print(x)
return print(y)

11. Modifikovaná syntaxe volání funkcí

V Moonscriptu došlo i k modifikaci (resp. přesněji řečeno k rozšíření) syntaxe při volání funkcí. Nejprve se podívejme na skript, který je sice psaný v Moonscriptu, ale je současně kompatibilní i s Luou. Povšimněte si, že u funkce s jediným parametrem typu řetězec není nutné okolo tohoto parametru psát kulaté závorky:

--
-- Skript zapsaný v jazyce Moonscript
--
 
print "Hello"
print()
print("world")
print("foo", "bar")

Výsledek transpřekladu:

--
-- Skript transpilovaný do jazyka Lua
--
 
print("Hello")
print()
print("world")
return print("foo", "bar")

V Moonscriptu jsou ve skutečnosti závorky okolo parametrů volitelné a není je nutné používat. Má to ovšem jeden háček – jak zajistit volání funkce bez parametrů. To je řešeno přidáním znaku ! za jméno funkce (ovšem pokud vám to připadne divné, je pochopitelně stále možné použít prázdné kulaté závorky):

--
-- Skript zapsaný v jazyce Moonscript
--
 
print "Hello"
print!
print "world"
print "foo", "bar"

Výsledek transpřekladu:

--
-- Skript transpilovaný do jazyka Lua
--
 
print("Hello")
print()
print("world")
return print("foo", "bar")
Poznámka: až při pohledu na zdrojové kódy psané v CoffeeScriptu nebo Moonscriptu začne být zřejmé, kolik „balastu“ vlastně musíme psát v céčkové větvi programovacích jazyků.

12. Definice nových funkcí operátorem ->

V CoffeeScriptu se (alespoň v doméně mainstreamových programovacích jazyků) poprvé objevil „operátor šipky“ použitý pro definici nových anonymních funkcí, pochopitelně s tím, že výslednou funkci je možné přiřadit symbolu a tím ji udělat neanonymní (pojmenovanou). Kromě operátoru „tenké“ šipky -> existuje ještě operátor „tlusté“ šipky =>, který má odlišný význam, protože mj. zajišťuje navázání na v daném kontextu aktuální hodnotu this, resp. self. Později se tento operátor (po určité modifikaci sémantiky, ke které se ještě vrátíme) objevil i v ES6, takže je dnes široce používán.

Vraťme se však k operátoru „tenké“ šipky, kterým lze v Moonscriptu nahradit klasickou definici funkce s využitím klíčových slov function, end a return. Tento operátor byl převzat z CoffeeScriptu, kde měl následující podobu:

--
-- Skript zapsaný v jazyce CoffeeScript
--
 
square = (x) -> x * x
cube   = (x) -> square(x) * x

Transpřeklad do JavaScriptu vypadá následovně:

--
-- Skript transpilovaný do jazyka JavaScript
--
 
 
var cube, square;
 
square = function(x) {
  return x * x;
};
 
cube = function(x) {
  return square(x) * x;
};

13. Prázdná funkce bez parametrů

Začneme poněkud umělým příkladem, a to konkrétně funkcí bez parametrů, která navíc ani nemá žádné tělo. V Moonscriptu se tato funkce deklaruje a volá takto:

--
-- Skript zapsaný v jazyce Moonscript
--
 
noop_function = ->
 
noop_function!

Výsledkem transpřekladu je skutečně definice nové funkce, která má prázdné tělo, tedy: function() end:

--
-- Skript transpilovaný do jazyka Lua
--
 
local noop_function
noop_function = function() end
return noop_function()

14. Funkce s tělem, ovšem bez parametrů

Druhou funkcí vytvořenou operátorem šipky, kterou si dnes ukážeme, je funkce, která má tělo, ovšem neakceptuje žádné parametry. V případě, že tělo této funkce obsahuje pouze jediný příkaz, je ji možné zapsat (a následně zavolat) následovně:

--
-- Skript zapsaný v jazyce Moonscript
--
 
noarg_function = -> print "Hello, world!"
 
noarg_function!

Povšimněte si, že při transpřekladu do jazyka Lua bude poslední (a současně i jediný) příkaz v těle funkce zavolán uvnitř konstrukce return, což je pro Moonscript typické:

--
-- Skript transpilovaný do jazyka Lua
--
 
local noarg_function
noarg_function = function()
  return print("Hello, world!")
end
return noarg_function()

Funkce obsahující více příkazů ve svém těle se typicky zapisuje na větší počet řádků:

--
-- Skript zapsaný v jazyce Moonscript
--
 
noarg_function = ->
    message = "Hello, "
    message ..= "world!"
    print message
 
noarg_function!

Ze skriptu transformovaného do jazyka Lua je patrné, že poslední příkaz v těle funkce je opět zavolán v rámci konstrukce return a tudíž je jeho návratová hodnota návratovou hodnotou celé funkce:

--
-- Skript transpilovaný do jazyka Lua
--
 
local noarg_function
noarg_function = function()
  local message = "Hello, "
  message = message .. "world!"
  return print(message)
end
return noarg_function()
Poznámka: všechny funkce, tedy i print, vrací hodnotu. Touto hodnotou je v případě neexistence konstrukce return hodnota nil (ovšem v Moonscriptu je return vždy přidán automaticky).

15. Návratová hodnota funkce

Předchozí funkce vracely návratovou hodnotu volané funkce print, což neukazuje všechny možnosti, které nám programovací jazyk Moonscript nabízí. Ukažme si tedy způsob definice funkce, která vrací skutečnou (vypočtenou) hodnotu. Prozatím nevíme, jak se deklaruje funkce s parametry, takže použijeme funkci bez parametrů, ovšem s návratovou hodnotou. Zápis využívající explicitní konstrukci return bude vypadat takto:

--
-- Skript zapsaný v jazyce Moonscript
--
 
my_random = ->
    return math.random(1, 10)
 
for i = 0, 10 do
    print my_random!

Překlad do jazyka Lua:

--
-- Skript transpilovaný do jazyka Lua
--
 
local my_random
my_random = function()
  return math.random(1, 10)
end
for i = 0, 10 do
  print(my_random())
end

Ovšem konstrukci return je ve skutečnosti možné vynechat, protože hodnota posledního výrazu ve funkci je z této funkce vrácena automaticky:

--
-- Skript zapsaný v jazyce Moonscript
--
 
my_random = ->
    math.random(1, 10)
 
for i = 0, 10 do
    print my_random!

Překlad do jazyka Lua je v tomto případě totožný s předchozím příkladem:

--
-- Skript transpilovaný do jazyka Lua
--
 
local my_random
my_random = function()
  return math.random(1, 10)
end
for i = 0, 10 do
  print(my_random())
end

16. Definice funkce s parametry

Nyní se podívejme na způsob zápisu funkce s parametry. Jména těchto parametrů je nutné zapsat do kulatých závorek a uvést je před operátor šipky. Jednoduchá funkce vracející součin svých dvou parametrů tedy může vypadat takto:

--
-- Skript zapsaný v jazyce Moonscript
--
 
multiply = (x, y) -> x * y
 
print multiply 6,7
Poznámka: opět pochopitelně platí, že poslední (zde jediný) výraz je současně i návratovou hodnotou celé funkce.

Takto nadefinovaná funkce je transpilována na příslušný Lua skript následujícím způsobem:

--
-- Skript transpilovaný do jazyka Lua
--
 
local multiply
multiply = function(x, y)
  return x * y
end
return print(multiply(6, 7))

17. Návrat většího množství hodnot z funkce

V případě, že je nutné z funkce vrátit větší množství hodnot (což dovoluje již programovací jazyk Lua), lze použít následující styl zápisu:

--
-- Skript zapsaný v jazyce Moonscript
--
 
swap = (x, y) -> y, x
 
print swap "foo", "bar"

V tomto případě je výsledek posledního (a jediného) výrazu ve funkci vrácen jako dvojice parametrů, což si můžeme snadno ověřit spuštěním transpilovaného kódu, který by měl vypsat předané parametry, ovšem v opačném pořadí:

--
-- Skript transpilovaný do jazyka Lua
--
 
local swap
swap = function(x, y)
  return y, x
end
return print(swap("foo", "bar"))

18. Parametry funkce s implicitní hodnotou

Poněkud složitější je práce transpřekladače Moonscriptu ve chvíli, kdy budeme potřebovat deklarovat funkci, jejích (některé) parametry budou mít výchozí hodnotu. To je jazyková konstrukce, kterou jazyk Lua nepodporuje, ovšem je to v praxi velmi užitečná konstrukce. Proto ji můžeme použít v Moonscriptu. Způsob zápisu odpovídá (například) programovacímu jazyku Python:

--
-- Skript zapsaný v jazyce Moonscript
--
 
sum = (x=0, y=0, z=0) -> x + y + z
 
print sum!
print sum 1
print sum 1, 2
print sum 1, 2, 3

Vidíme, že funkci sum lze volat bez parametrů, s jedním parametrem, se dvěma parametry nebo s parametry třemi. Transpřeklad do jazyka Lua bude vypadat takto:

--
-- Skript transpilovaný do jazyka Lua
--
 
local sum
sum = function(x, y, z)
  if x == nil then
    x = 0
  end
  if y == nil then
    y = 0
  end
  if z == nil then
    z = 0
  end
  return x + y + z
end
print(sum())
print(sum(1))
print(sum(1, 2))
return print(sum(1, 2, 3))

Vidíme, že parametry jsou vyhodnocovány v těle funkce! To nám umožňuje zajímavý trik – výchozí hodnoty některých parametrů mohou být odvozeny z jiných výchozích parametrů, protože víme, že výpočet skutečných hodnot parametrů se provádí zleva doprava:

webcast bezpečnostní katastrofy

--
-- Skript zapsaný v jazyce Moonscript
--
 
weird_sum = (x=0, y=x+1, z=y*2) -> x + y + z
 
print sum!
print sum 1
print sum 1, 2
print sum 1, 2, 3

Výsledkem je korektní kód reprezentovaný v jazyce Lua:

--
-- Skript transpilovaný do jazyka Lua
--
 
local weird_sum
weird_sum = function(x, y, z)
  if x == nil then
    x = 0
  end
  if y == nil then
    y = x + 1
  end
  if z == nil then
    z = y * 2
  end
  return x + y + z
end
print(sum())
print(sum(1))
print(sum(1, 2))
return print(sum(1, 2, 3))

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

Všechny dnes popsané demonstrační příklady určené pro poslední stabilní verzi transpřekladače Moonscript byly uloženy do Git repositáře, který je dostupný na adrese https://github.com/tisnik/moonscript-examples. Tyto demonstrační příklady si můžete v případě potřeby stáhnout i jednotlivě bez nutnosti klonovat celý (dnes prozatím malý) repositář:

# Příklad Stručný popis příkladu Adresa (zdrojový kód)
1 01_hello_world.lua tradiční program typu „Hello, world!“ napsaný v Lue https://github.com/tisnik/moonscript-examples/blob/master/01_he­llo_world.lua
2 02_hello_world.lua okolo jediného parametru funkce není zapotřebí psát závorky https://github.com/tisnik/moonscript-examples/blob/master/02_he­llo_world.lua
3 03_hello_world.moon tradiční program typu „Hello, world!“ napsaný v Moonscriptu https://github.com/tisnik/moonscript-examples/blob/master/03_he­llo_world.moon
4 03_hello_world.lua transpřeklad předchozího zdrojového kódu do jazyka Lua https://github.com/tisnik/moonscript-examples/blob/master/03_he­llo_world.lua
5 04_local_variable.moon lokální proměnné v Moonscriptu https://github.com/tisnik/moonscript-examples/blob/master/04_lo­cal_variable.moon
6 04_local_variable.lua transpřeklad předchozího zdrojového kódu do jazyka Lua https://github.com/tisnik/moonscript-examples/blob/master/04_lo­cal_variable.lua
7 05_local_variable.moon opětovné přiřazení do lokální proměnné https://github.com/tisnik/moonscript-examples/blob/master/05_lo­cal_variable.moon
8 05_local_variable.lua transpřeklad předchozího zdrojového kódu do jazyka Lua https://github.com/tisnik/moonscript-examples/blob/master/05_lo­cal_variable.lua
9 06_local_variable.moon čtení z neexistující proměnné https://github.com/tisnik/moonscript-examples/blob/master/06_lo­cal_variable.moon
10 06_local_variable.lua transpřeklad předchozího zdrojového kódu do jazyka Lua https://github.com/tisnik/moonscript-examples/blob/master/06_lo­cal_variable.lua
11 07_string_interpolation.moon interpolace řetězců v Moonscriptu https://github.com/tisnik/moonscript-examples/blob/master/07_strin­g_interpolation.moon
12 07_string_interpolation.lua transpřeklad předchozího zdrojového kódu do jazyka Lua https://github.com/tisnik/moonscript-examples/blob/master/07_strin­g_interpolation.lua
13 08_string_interpolation.moon interpolace řetězců, složitější příklad v Moonscriptu https://github.com/tisnik/moonscript-examples/blob/master/08_strin­g_interpolation.moon
14 08_string_interpolation.lua transpřeklad předchozího zdrojového kódu do jazyka Lua https://github.com/tisnik/moonscript-examples/blob/master/08_strin­g_interpolation.lua
15 09_string_interpolation.moon zákaz interpolace řetězců v Moonscriptu https://github.com/tisnik/moonscript-examples/blob/master/09_strin­g_interpolation.moon
16 09_string_interpolation.lua transpřeklad předchozího zdrojového kódu do jazyka Lua https://github.com/tisnik/moonscript-examples/blob/master/09_strin­g_interpolation.lua
17 10_multiline_string.moon víceřádkové řetězce v Moonscriptu https://github.com/tisnik/moonscript-examples/blob/master/10_mul­tiline_string.moon
18 10_multiline_string.lua transpřeklad předchozího zdrojového kódu do jazyka Lua https://github.com/tisnik/moonscript-examples/blob/master/10_mul­tiline_string.lua
19 11_comparison_operator.moon nový operátor pro test na nerovnost v Moonscriptu https://github.com/tisnik/moonscript-examples/blob/master/11_com­parison_operator.moon
20 11_comparison_operator.lua transpřeklad předchozího zdrojového kódu do jazyka Lua https://github.com/tisnik/moonscript-examples/blob/master/11_com­parison_operator.lua
21 12_simple_assignment.moon operátor jednoduchého přiřazení https://github.com/tisnik/moonscript-examples/blob/master/12_sim­ple_assignment.moon
22 12_simple_assignment.lua transpřeklad předchozího zdrojového kódu do jazyka Lua https://github.com/tisnik/moonscript-examples/blob/master/12_sim­ple_assignment.lua
23 13_operator_assignment.moon přiřazení zkombinované s aritmetickou operací https://github.com/tisnik/moonscript-examples/blob/master/13_o­perator_assignment.moon
24 13_operator_assignment.lua transpřeklad předchozího zdrojového kódu do jazyka Lua https://github.com/tisnik/moonscript-examples/blob/master/13_o­perator_assignment.lua
25 14_operator_assignment.moon přiřazení zkombinované s připojením řetězce https://github.com/tisnik/moonscript-examples/blob/master/14_o­perator_assignment.moon
26 14_operator_assignment.lua transpřeklad předchozího zdrojového kódu do jazyka Lua https://github.com/tisnik/moonscript-examples/blob/master/14_o­perator_assignment.lua
27 15_operator_assignment.moon přiřazení zkombinované s logickou operací https://github.com/tisnik/moonscript-examples/blob/master/15_o­perator_assignment.moon
28 15_operator_assignment.lua transpřeklad předchozího zdrojového kódu do jazyka Lua https://github.com/tisnik/moonscript-examples/blob/master/15_o­perator_assignment.lua
29 16_function_parameters.moon volání funkce bez parametrů, s jedním parametrem i více parametry https://github.com/tisnik/moonscript-examples/blob/master/16_fun­ction_parameters.moon
30 16_function_parameters.lua transpřeklad předchozího zdrojového kódu do jazyka Lua https://github.com/tisnik/moonscript-examples/blob/master/16_fun­ction_parameters.lua
31 17_function_no_parenthesis.moon volání funkce bez použití kulatých závorek https://github.com/tisnik/moonscript-examples/blob/master/17_fun­ction_no_parenthesis.moon
32 17_function_no_parenthesis.lua transpřeklad předchozího zdrojového kódu do jazyka Lua https://github.com/tisnik/moonscript-examples/blob/master/17_fun­ction_no_parenthesis.lua
33 18_arrow_empty_function.moon deklarace prázdné funkci s využitím operátoru šipky https://github.com/tisnik/moonscript-examples/blob/master/18_a­rrow_empty_function.moon
34 18_arrow_empty_function.lua transpřeklad předchozího zdrojového kódu do jazyka Lua https://github.com/tisnik/moonscript-examples/blob/master/18_a­rrow_empty_function.lua
35 19_arrow_noarg_function.moon deklarace funkce bez parametrů s využitím operátoru šipky https://github.com/tisnik/moonscript-examples/blob/master/19_a­rrow_noarg_function.moon
36 19_arrow_noarg_function.lua transpřeklad předchozího zdrojového kódu do jazyka Lua https://github.com/tisnik/moonscript-examples/blob/master/19_a­rrow_noarg_function.lua
37 20_arrow_noarg_larger_function.moon delší funkce bez parametrů vytvořená s využitím operátoru šipky https://github.com/tisnik/moonscript-examples/blob/master/20_a­rrow_noarg_larger_function­.moon
38 20_arrow_noarg_larger_function.lua transpřeklad předchozího zdrojového kódu do jazyka Lua https://github.com/tisnik/moonscript-examples/blob/master/20_a­rrow_noarg_larger_function­.lua
39 21_arrow_return_value.moon funkce vracející jednu hodnotu vytvořená operátorem šipky https://github.com/tisnik/moonscript-examples/blob/master/21_a­rrow_return_value.moon
40 21_arrow_return_value.lua transpřeklad předchozího zdrojového kódu do jazyka Lua https://github.com/tisnik/moonscript-examples/blob/master/21_a­rrow_return_value.lua
41 22_arrow_return_value.moon návratová hodnota funkce bez nutnosti použití klíčového slova return https://github.com/tisnik/moonscript-examples/blob/master/22_a­rrow_return_value.moon
42 22_arrow_return_value.lua transpřeklad předchozího zdrojového kódu do jazyka Lua https://github.com/tisnik/moonscript-examples/blob/master/22_a­rrow_return_value.lua
43 23_arrow_function_parameters.moon parametry funkce vytvořené operátorem šipky https://github.com/tisnik/moonscript-examples/blob/master/23_a­rrow_function_parameters.mo­on
44 23_arrow_function_parameters.lua transpřeklad předchozího zdrojového kódu do jazyka Lua https://github.com/tisnik/moonscript-examples/blob/master/23_a­rrow_function_parameters.lua
45 24_arrow_multiple_return_values.moon více návratových hodnot funkce https://github.com/tisnik/moonscript-examples/blob/master/24_a­rrow_multiple_return_valu­es.moon
46 24_arrow_multiple_return_values.lua transpřeklad předchozího zdrojového kódu do jazyka Lua https://github.com/tisnik/moonscript-examples/blob/master/24_a­rrow_multiple_return_valu­es.lua
47 25_arrow_default_arguments.moon parametry s implicitní hodnotou https://github.com/tisnik/moonscript-examples/blob/master/25_a­rrow_default_arguments.mo­on
48 25_arrow_default_arguments.lua transpřeklad předchozího zdrojového kódu do jazyka Lua https://github.com/tisnik/moonscript-examples/blob/master/25_a­rrow_default_arguments.lua
49 26_arrow_default_arguments.moon způsob inicializace parametrů s implicitní hodnotou https://github.com/tisnik/moonscript-examples/blob/master/26_a­rrow_default_arguments.mo­on
50 26_arrow_default_arguments.lua transpřeklad předchozího zdrojového kódu do jazyka Lua https://github.com/tisnik/moonscript-examples/blob/master/26_a­rrow_default_arguments.lua

20. Odkazy na Internetu

  1. Stránky projektu Moonscript
    https://moonscript.org/
  2. Moonscript na GitHubu
    https://github.com/leafo/moonscript
  3. MoonScript online compiler
    https://moonscript.org/compiler/
  4. Vydání Moonscriptu
    https://github.com/leafo/mo­onscript/releases
  5. Moonscript-vim
    https://github.com/leafo/moonscript-vim
  6. Moonscript Examples
    https://github.com/leafo/mo­onscript/wiki/Moonscript-Examples
  7. CoffeeScript
    https://coffeescript.org/
  8. CoffeeScript na Wikipedii
    https://en.wikipedia.org/wi­ki/CoffeeScript
  9. CoffeeScript: řádně oslazený JavaScript
    https://zdrojak.cz/clanky/coffeescript-radne-oslazeny-javascript/
  10. CoffeeScript: druhá dávka steroidů pro vaše skripty
    https://zdrojak.cz/clanky/coffeescript-druha-davka-steroidu-pro-vase-skripty/
  11. Why CoffeeScript is still alive
    https://codeburst.io/why-coffeescript-is-still-alive-aeb369b91b85
  12. The CoffeeScript Wiki
    https://github.com/jashke­nas/coffeescript/wiki
  13. CoffeeScript In The Wild
    https://github.com/jashke­nas/coffeescript/wiki/In-The-Wild
  14. How CoffeeScript Got Forgotten
    https://betterprogramming.pub/how-coffeescript-got-forgotten-812328225987
  15. ULua: Universal Lua Distribution
    https://ulua.io/index.html
  16. LuaRocks
    https://luarocks.org/
  17. Awesome Lua – A curated list of quality Lua packages and resources.
    https://github.com/LewisJEllis/awesome-lua
  18. LuaJIT
    https://luajit.org/
  19. Running LuaJIT
    https://luajit.org/running.html
  20. LuaJIT na GitHubu
    https://github.com/luajit
  21. Lua Implementations
    http://lua-users.org/wiki/LuaImplementations
  22. Coconut: funkcionální jazyk s pattern matchingem kompatibilní s Pythonem
    https://www.root.cz/clanky/coconut-funkcionalni-jazyk-s-pattern-matchingem-kompatibilni-s-pythonem/
  23. Coconut aneb funkcionální nadstavba nad Pythonem (2.část)
    https://www.root.cz/clanky/coconut-aneb-funkcionalni-nadstavba-nad-pythonem-2-cast/
  24. Coconut: Simple, elegant, Pythonic functional programming
    http://coconut-lang.org/
  25. coconut 1.1.0 (Python package index)
    https://pypi.python.org/py­pi/coconut/1.1.0
  26. Coconut Tutorial
    http://coconut.readthedoc­s.io/en/master/HELP.html
  27. Coconut FAQ
    http://coconut.readthedoc­s.io/en/master/FAQ.html
  28. Coconut Documentation
    http://coconut.readthedoc­s.io/en/master/DOCS.html
  29. Coconut na Redditu
    https://www.reddit.com/r/Pyt­hon/comments/4owzu7/coconut_fun­ctional_programming_in_pyt­hon/
  30. Repositář na GitHubu
    https://github.com/evhub/coconut
  31. patterns
    https://github.com/Suor/patterns
  32. Source-to-source compiler
    https://en.wikipedia.org/wiki/Source-to-source_compiler
  33. The Lua VM, on the Web
    https://kripken.github.io/lu­a.vm.js/lua.vm.js.html
  34. Lua.vm.js REPL
    https://kripken.github.io/lu­a.vm.js/repl.html
  35. lua2js
    https://www.npmjs.com/package/lua2js
  36. Wisp na GitHubu
    https://github.com/Gozala/wisp
  37. Wisp playground
    http://www.jeditoolkit.com/try-wisp/
  38. REPL v prohlížeči
    http://www.jeditoolkit.com/in­teractivate-wisp/
  39. Minification (programming)
    https://en.wikipedia.org/wi­ki/Minification_(programmin­g)
  40. Roblox
    https://en.wikipedia.org/wiki/Roblox
  41. Category:Lua (programming language)-scriptable game engines
    https://en.wikipedia.org/wi­ki/Category:Lua_(programmin­g_language)-scriptable_game_engines
  42. Goodbye Lua (shrnutí následujícího článku)
    https://www.reddit.com/r/lu­a/comments/4ld6ao/goodbye_lu­a/
  43. Goodbye, Lua
    https://realmensch.org/2016/05/28/go­odbye-lua/
  44. 6th Edition – ECMAScript 2015
    https://en.wikipedia.org/wi­ki/ECMAScript#6th_Edition_%E2%80%93_EC­MAScript_2015

Autor článku

Pavel Tišnovský vystudoval VUT FIT a v současné době pracuje ve společnosti Red Hat, kde vyvíjí nástroje pro OpenShift.io.