Hlavní navigace

Moonscript: jazyk inspirovaný CoffeeScriptem určený pro ekosystém jazyka Lua (dokončení)

18. 11. 2021
Doba čtení: 37 minut

Sdílet

 Autor: Depositphotos
Dnes dokončíme popis možností jazyka Moonscript, který je transpilován do jazyka Lua. Ukážeme si použití řezů, programových smyček vracejících hodnoty, deklaraci tříd či tzv. destructuring.

Obsah

1. Specifikace řezu tabulkou v programové smyčce for-each

2. Vliv použití záporného horního indexu při řezu tabulkou

3. Explicitní krok specifikovaný při řezu tabulkou

4. Počítaná programová smyčka typu for ve funkci hodnoty

5. Realizace filtru programovou smyčkou typu for

6. Vrácení hodnot generovaných smyčkou for z funkce

7. Nepatrně zjednodušený zápis programové smyčky typu while

8. Objektově orientované programování v jazyce Moonscript

9. Deklarace třídy s konstruktorem, přístup k atributům objektu

10. Zjednodušený přístup k atributům objektů pomocí operátoru @

11. Volání metod objektu s využitím operátoru \

12. Metody bez parametrů a s jednopříkazovým tělem

13. Předání parametrů konstruktoru objektu

14. Volání metod přímo z konstruktoru

15. Použití programové konstrukce with

16. Blok do

17. Destructuring

18. Příloha: zápis řezu (slice) v různých programovacích jazycích

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

20. Odkazy na Internetu

1. Specifikace řezu tabulkou v programové smyčce for-each

Již minule jsme se v kapitole o generátorové notaci seznamu (list comprehension) zmínili o možnosti použít pouze vybrané prvky ze zdrojového seznamu (resp. v terminologii jazyka Lua z tabulky), a to s využitím takzvaných řezů (slice), které můžeme v podobné podobě znát například z Pythonu, z jazyka Go popř. z programovacího jazyka Rust (viz též přílohu v osmnácté kapitole). V případě Moonscriptu není možné řez použít v běžných výrazech (což je poměrně velké omezení), ovšem například ho můžeme zapsat v programové smyčce typu for-each, kterou lze mj. zkonstruovat i takto:

--
-- Skript zapsaný v jazyce Moonscript
--
 
items = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
 
for item in *items[2,8]
  print item

Transpilace takto zapsané programové smyčky do jazyka Lua naznačuje způsob převodu řezu na běžnou počítanou smyčku:

--
-- Skript transpilovaný do jazyka Lua
--
 
local items = {
  1,
  2,
  3,
  4,
  5,
  6,
  7,
  8,
  9,
  10
}
local _max_0 = 8
for _index_0 = 2, _max_0 < 0 and #items + _max_0 or _max_0 do
  local item = items[_index_0]
  print(item)
end

Po spuštění tohoto demonstračního příkladu se vypíšou hodnoty od 2 do 8:

2
3
4
5
6
7
8
Poznámka: na tomto místě je vhodné zdůraznit, že se vypíše i hodnota 8, a to na rozdíl od některých jiných programovacích jazyků, v nichž se hodnoty zapisované do řezu nechápou jako indexy prvků, ale jako indexy mezer mezi prvky.

V případě, že se vynechá první index, dosadí se namísto něj automaticky jednička (číslování prvků v Moonscriptu začíná od jedničky):

--
-- Skript zapsaný v jazyce Moonscript
--
 
items = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
 
for item in *items[,8]
  print item

Opět si uveďme způsob transpilace do jazyka Lua:

--
-- Skript transpilovaný do jazyka Lua
--
 
local items = {
  1,
  2,
  3,
  4,
  5,
  6,
  7,
  8,
  9,
  10
}
local _max_0 = 8
for _index_0 = 1, _max_0 < 0 and #items + _max_0 or _max_0 do
  local item = items[_index_0]
  print(item)
end

Výsledek je v tomto případě očekávatelný:

1
2
3
4
5
6
7
8

Vynechat je ovšem možné i druhý index. V tomto případě se namísto něho dosadí délka pole/tabulky:

--
-- Skript zapsaný v jazyce Moonscript
--
 
items = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
 
for item in *items[4,]
  print item

Transpřeklad předchozí programové smyčky tak, že horní mezí bude skutečně délka tabulky, si můžeme snadno ověřit – viz zvýrazněnou část kódu:

--
-- Skript transpilovaný do jazyka Lua
--
 
local items = {
  1,
  2,
  3,
  4,
  5,
  6,
  7,
  8,
  9,
  10
}
for _index_0 = 4, #items do
  local item = items[_index_0]
  print(item)
end

Výsledek, který po spuštění předchozího skriptu získáme, bude vypadat následovně:

4
5
6
7
8
9
10
Poznámka: je zde vidět jedna z výhod indexování od jedničky – délka tabulky odpovídá indexu posledního prvku. Tento způsob má ovšem i některé nevýhody; například mnoho programátorů je dnes navyklých spíše na indexování od nuly než od jedničky (na druhou stranu ovšem doménové jazyky popř. jazyky orientované na matematiku, číslování od jedničky relativně často používají).

2. Vliv použití záporného horního indexu při řezu tabulkou

Horní index je možné zapsat formou záporného čísla. V tomto případě se počítá od konce seznamu/tabulky, nikoli od jejího začátku. Ostatně si můžeme toto chování velmi snadno ověřit:

--
-- Skript zapsaný v jazyce Moonscript
--
 
items = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
 
for item in *items[3,-3]
  print item

Implementace při transpilaci do jazyka Lua je přímočará a vlastně ani nevyžaduje žádné další kroky v porovnání s předchozími demonstračními příklady:

--
-- Skript transpilovaný do jazyka Lua
--
 
local items = {
  1,
  2,
  3,
  4,
  5,
  6,
  7,
  8,
  9,
  10
}
local _max_0 = -3
for _index_0 = 3, _max_0 < 0 and #items + _max_0 or _max_0 do
  local item = items[_index_0]
  print(item)
end

Je zde použita podmínka zapsaná pomocí and-or, kterou lze snadno dešifrovat pro kladnou i zápornou hodnotu max a seznamu délky deset prvků:

max max < 0 #items + max max < 0 and #items + max or max Poznámka
+5 false 15 5 podmínka nesplněna → vyhodnotí se „větev“ za or
–4 true 6 6 podmínka splněna → vyhodnotí se větev za and
Poznámka: je zde využito zkráceného vyhodnocení logických výrazů, kdy se na základě hodnoty levého operandu rozhoduje, zda má smysl vyhodnotit pravý operand či nikoli.

Výsledkem po spuštění předchozího příkladu tedy bude sekvence hodnot:

3
4
5
6
7

3. Explicitní krok specifikovaný při řezu tabulkou

Mnoho programovacích jazyků u řezů podporuje i určení kroku mezi prvky. I tuto konstrukci jazyk Moonscript podporuje, takže si ji můžeme otestovat. V následujícím demonstračním příkladu se řezem vyberou všechny prvky od začátku do konce seznamu, ovšem s krokem 2 (tedy každý druhý prvek):

--
-- Skript zapsaný v jazyce Moonscript
--
 
items = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
 
for item in *items[,,2]
  print item

V takto jednoduchém příkladu je transpilace do jazyka Lua velmi přímočará, protože krok podporuje i jazyk Lua:

--
-- Skript transpilovaný do jazyka Lua
--
 
local items = {
  1,
  2,
  3,
  4,
  5,
  6,
  7,
  8,
  9,
  10
}
for _index_0 = 1, #items, 2 do
  local item = items[_index_0]
  print(item)
end

Výsledek získaný po spuštění tohoto skriptu:

1
3
5
7
9

Programové smyčky s jediným příkazem v těle lze zapsat na jediný programový řádek, ovšem v tomto případě je nutné přidat klíčové slovo do:

--
-- Skript zapsaný v jazyce Moonscript
--
 
items = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
 
for item in *items[,,2] do print item

Transpřeklad tohoto skriptu do programovacího jazyka Lua je přímočarý:

--
-- Skript transpilovaný do jazyka Lua
--
 
local items = {
  1,
  2,
  3,
  4,
  5,
  6,
  7,
  8,
  9,
  10
}
for _index_0 = 1, #items, 2 do
  local item = items[_index_0]
  print(item)
end

4. Počítaná programová smyčka typu for ve funkci hodnoty

Již v úvodním článku o programovacím jazyce Moonscript jsme si řekli, že většina konstrukcí v tomto jazyku je ve skutečnosti hodnotou, kterou je možné dále zpracovat. Výjimkou není ani smyčka for popř. smyčka typu for-each, která vrací hodnoty získané v každé iteraci. Můžeme si to snadno ukázat na příkladu počítané smyčky, která vrátí deset hodnot získaných vyhodnocením zlomků 1/1, 1/2, 1/3 až 1/10. Povšimněte si, že tělo smyčky je tvořeno pouze jediným výrazem:

--
-- Skript zapsaný v jazyce Moonscript
--
 
r = for i=1,10 1/i
 
for item in *r do print item

Zdánlivě triviální jednořádkový zápis je transformován do deseti řádků v jazyce Lua, což ukazuje, jak sémanticky silný Moonscript je:

--
-- Skript transpilovaný do jazyka Lua
--
 
local r
do
  local _accum_0 = { }
  local _len_0 = 1
  for i = 1, 10 do
    _accum_0[_len_0] = 1 / i
    _len_0 = _len_0 + 1
  end
  r = _accum_0
end
for _index_0 = 1, #r do
  local item = r[_index_0]
  print(item)
end

5. Realizace filtru programovou smyčkou typu for

V programových smyčkách implementovaných (nejenom) v jazyce Moonscript je možné použít konstrukci continue, která slouží k předčasnému ukončení jedné iterace. V případě, že je programová smyčka for použita jako hodnota, má continue ještě jeden důležitý význam – prvek, který by měl být v rámci dané iterace vypočítán, není ve výsledku použit. Toto chování je možné využít při tvorbě filtrů – ve smyčce generujeme hodnoty prvků seznamu nebo slovníku, ovšem pro některé vstupní hodnoty budou prvky vyfiltrovány:

--
-- Skript zapsaný v jazyce Moonscript
--
 
r = for i=1,10
  if i >= 4 and i <= 7 continue
  i*2
 
for item in *r do print item

Předchozí zápis vytvoří seznam s celočíselnými hodnotami 1 až 10, ovšem bez prvků s hodnotami 4, 5, 6 a 7:

1
2
3
8
9
10

A takto bude vypadat transpřeklad předchozího skriptu do programovacího jazyka Lua:

--
-- Skript transpilovaný do jazyka Lua
--
 
local r
do
  local _accum_0 = { }
  local _len_0 = 1
  for i = 1, 10 do
    local _continue_0 = false
    repeat
      if i >= 4 and i <= 7 then
        _continue_0 = true
        break
      end
      local _value_0 = i * 2
      _accum_0[_len_0] = _value_0
      _len_0 = _len_0 + 1
      _continue_0 = true
    until true
    if not _continue_0 then
      break
    end
  end
  r = _accum_0
end
for _index_0 = 1, #r do
  local item = r[_index_0]
  print(item)
end

6. Vrácení hodnot generovaných smyčkou for z funkce

Víme již, že smyčky for mohou vracet hodnotu – seznam nebo slovník. Také již víme, že poslední výraz ve funkci je implicitně použit jako návratová hodnota dané funkce. Obě zmíněné vlastnosti by měly vést k tomu, že pokud v těle funkce použijeme smyčku for, bude z funkce implicitně vrácen seznam nebo slovník získaný z iteračních cyklů této smyčky. Ve skutečnosti tomu tak ovšem není a to z toho důvodu, že tvorba návratové hodnoty je relativně složitá/pomalá a mnohdy se tato hodnota zrovna v případě smyček nepoužije (smyčky bývají použity imperativně). Proto je nutné v tomto případě (a jedná se o jediný případ) explicitně použít konstrukci return:

--
-- Skript zapsaný v jazyce Moonscript
--
 
f1 = -> for i=1,10 do i
f2 = -> return for i=1,10 do i
 
print f1!
print f2!

Povšimněte si, jak zcela odlišným způsobem jsou transpilovány funkce f1 a f2:

--
-- Skript transpilovaný do jazyka Lua
--
 
local f1
f1 = function()
  for i = 1, 10 do
    local _ = i
  end
end
local f2
f2 = function()
  return (function()
    local _accum_0 = { }
    local _len_0 = 1
    for i = 1, 10 do
      _accum_0[_len_0] = i
      _len_0 = _len_0 + 1
    end
    return _accum_0
  end)()
end
print(f1())
return print(f2())
Poznámka: to znamená, že volání print f1! vytiskne hodnotu nil.

7. Nepatrně zjednodušený zápis programové smyčky typu while

Jen pro úplnost se zmiňme o nepatrně jednodušším způsobu zápisu programové smyčky typu while. V jazyce Moonscript není nutné používat klíčové slovo do ani smyčku ukončovat klíčovým slovem end, takže je možné použít následující styl zápisu:

--
-- Skript zapsaný v jazyce Moonscript
--
 
i = 0
while i <= 10
  print i
  i += 1

Transpřeklad tohoto skriptu do programovacího jazyka Lua je v tomto případě přímočarý:

--
-- Skript transpilovaný do jazyka Lua
--
 
local i = 0
while i <= 10 do
  print(i)
  i = i + 1
end

8. Objektově orientované programování v jazyce Moonscript

Minule jsme se zmínili o způsobu tvorby skriptů používajících OOP techniky přímo v jazyce Lua. Připomeňme si, že samotný programovací jazyk Lua sice nenabízí pro deklaraci tříd a objektů vlastní syntaxi, ale to neznamená, že by objektově orientované programování nebylo možné. Objekty je totiž možné vytvářet buď na základě uzávěrů (closures) při jejichž použití jsou atributy i metody objektu „zabaleny“ právě v uzávěru (ostatně stejný princip je využitý i v některých funkcionálních jazycích), a/nebo lze využít druhého způsobu založeného na asociativních polích a metatabulkách a metametodách. Tvorba objektů je pak ze sémantického hlediska podobná technice používané v původním JavaScriptu, který byl inspirovaný jazykem Self a takzvaným prototypováním.

Ukazovali jsme si i příklad jednoduché třídy nazvané Account s definicí atributu balance, s konstruktorem a taktéž s dvojicí metod nazvaných withdraw a deposit (každá přitom používá nepatrně odlišný způsob zápisu):

Account = {balance = 0}
 
function Account:new(o)
    -- create object if user does not provide one
    o = o or {}
    setmetatable(o, self)
    self.__index = self
    return o
end
 
function Account.withdraw(self, value)
    self.balance = self.balance - value
end
 
function Account:deposit(value)
    self.balance = self.balance + value
end
 
local a = Account:new{balance=0}
local b = Account:new{balance=50}
 
print("account A", a.balance)
print("account B", b.balance)
 
a:withdraw(100.00)
b:withdraw(100.00)
 
print("account A", a.balance)
print("account B", b.balance)
 
a:deposit(200.00)
b:deposit(200.00)
 
print("account A", a.balance)
print("account B", b.balance)

Předchozí příklad využíval triku spočívajícího v modifikaci metatabulky. Programovací jazyk Moonscript naproti tomu zavádí zcela odlišný způsob deklarace tříd i metod; liší se i přístup k atributům a volání metod.

9. Deklarace třídy s konstruktorem, přístup k atributům objektu

Ukažme si nyní, jak se deklarují třídy v jazyce Moonscript. Vytvoříme třídu pojmenovanou Customer. Tato třída bude mít konstruktor, který nastaví (automaticky vytvořené) atributy name a surname na hodnoty „N/A“. Dále zavoláme konstruktor, čímž se vytvoří instance této třídy a zobrazíme hodnoty obou atributů objektu:

--
-- Skript zapsaný v jazyce Moonscript
--
 
class Customer
  new: =>
    self.name = "N/A"
    self.surname = "N/A"
 
c = Customer!
print c.name
print c.surname
Poznámka: povšimněte si, že konstruktor je volán jménem třídy a vzhledem k tomu, že nemá žádné parametry, je nutné uvést při jeho volání vykřičník.

Překlad tohoto demonstračního příkladu do jazyka Lua je již dosti dlouhý – zde je jasně patrná větší úroveň abstrakce Moonscriptu:

--
-- Skript transpilovaný do jazyka Lua
--
 
local Customer
do
  local _class_0
  local _base_0 = { }
  _base_0.__index = _base_0
  _class_0 = setmetatable({
    __init = function(self)
      self.name = "N/A"
      self.surname = "N/A"
    end,
    __base = _base_0,
    __name = "Customer"
  }, {
    __index = _base_0,
    __call = function(cls, ...)
      local _self_0 = setmetatable({}, _base_0)
      cls.__init(_self_0, ...)
      return _self_0
    end
  })
  _base_0.__class = _class_0
  Customer = _class_0
end
local c = Customer()
print(c.name)
return print(c.surname)

10. Zjednodušený přístup k atributům objektů pomocí operátoru @

V předchozím demonstračním příkladu se k atributům objektu přistupovalo s využitím standardní tečkové notace, tedy následovně:

new: =>
  self.name = "N/A"
  self.surname = "N/A"

Uvnitř deklarace třídy popř. deklarace metod je však možné použít i nový operátor @, který nevyžaduje zápis self.. Jedná se o nepovinnou syntaxi, která je však užitečná, neboť přístup k atributu opticky zvýrazní. Následuje příklad použití tohoto „syntaktického cukru“:

--
-- Skript zapsaný v jazyce Moonscript
--
 
class Customer
  new: =>
    @name = "N/A"
    @surname = "N/A"
 
c = Customer!
print c.name
print c.surname

Transpřeklad do jazyka Lua je naprosto shodný s předchozím příkladem, o čemž se můžeme velmi snadno přesvědčit:

--
-- Skript transpilovaný do jazyka Lua
--
 
local Customer
do
  local _class_0
  local _base_0 = { }
  _base_0.__index = _base_0
  _class_0 = setmetatable({
    __init = function(self)
      self.name = "N/A"
      self.surname = "N/A"
    end,
    __base = _base_0,
    __name = "Customer"
  }, {
    __index = _base_0,
    __call = function(cls, ...)
      local _self_0 = setmetatable({}, _base_0)
      cls.__init(_self_0, ...)
      return _self_0
    end
  })
  _base_0.__class = _class_0
  Customer = _class_0
end
local c = Customer()
print(c.name)
return print(c.surname)

11. Volání metod objektu s využitím operátoru \

Dostáváme se k poněkud kontroverzní syntaxi použité v jazyku Moonscript. Jedná se o zápis volání metod. Nejdříve si ukažme způsob deklarace běžných metod:

set_name: (name) =>
  @name = name
 
set_surname: (surname) =>
  @surname = surname

Tyto metody se nevolají „tečkovou notací“, ale s využitím operátoru \:

c = Customer!
 
c\set_name "Foo"
c\set_surname "Bar"

Úplný skript s deklarací třídy s dvojicí metod může vypadat následovně:

--
-- Skript zapsaný v jazyce Moonscript
--
 
class Customer
  new: =>
    @name = "N/A"
    @surname = "N/A"
 
  set_name: (name) =>
    @name = name
 
  set_surname: (surname) =>
    @surname = surname
 
c = Customer!
 
print c.name
print c.surname
 
c\set_name "Foo"
c\set_surname "Bar"
 
print c.name
print c.surname

Z transpilovaného kódu je patrné, že se volání metod přeložilo na c:set_name(…) a c:set_surname(…):

--
-- Skript transpilovaný do jazyka Lua
--
 
local Customer
do
  local _class_0
  local _base_0 = {
    set_name = function(self, name)
      self.name = name
    end,
    set_surname = function(self, surname)
      self.surname = surname
    end
  }
  _base_0.__index = _base_0
  _class_0 = setmetatable({
    __init = function(self)
      self.name = "N/A"
      self.surname = "N/A"
    end,
    __base = _base_0,
    __name = "Customer"
  }, {
    __index = _base_0,
    __call = function(cls, ...)
      local _self_0 = setmetatable({}, _base_0)
      cls.__init(_self_0, ...)
      return _self_0
    end
  })
  _base_0.__class = _class_0
  Customer = _class_0
end
local c = Customer()
print(c.name)
print(c.surname)
c:set_name("Foo")
c:set_surname("Bar")
print(c.name)
return print(c.surname)

12. Metody bez parametrů a s jednopříkazovým tělem

Typickým příkladem metody bez parametrů jsou gettery (pokud je tedy vůbec budete chtít používat). Takové metody nemají žádné parametry a většinou obsahují pouze konstrukci určenou pro vrácení hodnoty atributu. Takové metody je možné v jazyce Moonscript psát skutečně minimalisticky:

get_name: =>
  @name
 
get_surname: =>
  @surname

Pochopitelně je možné zvolit i zápis celé metody na jediném řádku:

get_name: => @name
 
get_surname: => @surname

Následuje příklad použití takto deklarovaných metod:

--
-- Skript zapsaný v jazyce Moonscript
--
 
class Customer
  new: =>
    @name = "N/A"
    @surname = "N/A"
 
  set_name: (name) =>
    @name = name
 
  set_surname: (surname) =>
    @surname = surname
 
  get_name: =>
    @name
 
  get_surname: =>
    @surname
 
c = Customer!
 
print c\get_name!
print c\get_surname!
 
c\set_name "Foo"
c\set_surname "Bar"
 
print c\get_name!
print c\get_surname!

Transpřeklad do programovacího jazyka Lua:

--
-- Skript transpilovaný do jazyka Lua
--
 
local Customer
do
  local _class_0
  local _base_0 = {
    set_name = function(self, name)
      self.name = name
    end,
    set_surname = function(self, surname)
      self.surname = surname
    end,
    get_name = function(self)
      return self.name
    end,
    get_surname = function(self)
      return self.surname
    end
  }
  _base_0.__index = _base_0
  _class_0 = setmetatable({
    __init = function(self)
      self.name = "N/A"
      self.surname = "N/A"
    end,
    __base = _base_0,
    __name = "Customer"
  }, {
    __index = _base_0,
    __call = function(cls, ...)
      local _self_0 = setmetatable({}, _base_0)
      cls.__init(_self_0, ...)
      return _self_0
    end
  })
  _base_0.__class = _class_0
  Customer = _class_0
end
local c = Customer()
print(c:get_name())
print(c:get_surname())
c:set_name("Foo")
c:set_surname("Bar")
print(c:get_name())
return print(c:get_surname())
Poznámka: opět můžeme vidět dosti podstatně odlišné úrovně abstrakce.

13. Předání parametrů konstruktoru objektu

Konstruktor, který je realizován metodou nazvanou new, se chová podobně jako běžná metoda, tedy až na jediný rozdíl – vrací instanci právě vytvořeného objektu a nikoli uživatelem specifikovanou hodnotu. Ovšem v jiných ohledech se jedná o běžnou metodu, která tedy může akceptovat parametry. V následující ukázce je konstruktor upraven tak, aby akceptoval dva parametry. Taktéž je ukázán způsob volání takového konstruktoru:

--
-- Skript zapsaný v jazyce Moonscript
--
 
class Customer
  new: (name, surname) =>
    @name = name
    @surname = surname
 
  set_name: (name) =>
    @name = name
 
  set_surname: (surname) =>
    @surname = surname
 
  get_name: =>
    @name
 
  get_surname: =>
    @surname
 
c = Customer "foo", "bar"
 
print c\get_name!
print c\get_surname!
 
c\set_name "FOO"
c\set_surname "BAR"
 
print c\get_name!
print c\get_surname!

Transpilace tohoto krátkého skriptu do jazyka Lua je již dosti sáhodlouhá:

--
-- Skript transpilovaný do jazyka Lua
--
 
local Customer
do
  local _class_0
  local _base_0 = {
    set_name = function(self, name)
      self.name = name
    end,
    set_surname = function(self, surname)
      self.surname = surname
    end,
    get_name = function(self)
      return self.name
    end,
    get_surname = function(self)
      return self.surname
    end
  }
  _base_0.__index = _base_0
  _class_0 = setmetatable({
    __init = function(self, name, surname)
      self.name = name
      self.surname = surname
    end,
    __base = _base_0,
    __name = "Customer"
  }, {
    __index = _base_0,
    __call = function(cls, ...)
      local _self_0 = setmetatable({}, _base_0)
      cls.__init(_self_0, ...)
      return _self_0
    end
  })
  _base_0.__class = _class_0
  Customer = _class_0
end
local c = Customer("foo", "bar")
print(c:get_name())
print(c:get_surname())
c:set_name("FOO")
c:set_surname("BAR")
print(c:get_name())
return print(c:get_surname())

14. Volání metod přímo z konstruktoru

Často je nutné z konstruktoru nebo z jiných metod volat další metody toho samého objektu. Vzhledem k tomu, že Moonscript je jazykem s podporou běžných funkcí, je nutné nějakým způsobem odlišit volání běžné funkce od volání metody (Java tento problém nemá). K tomuto účelu slouží opět operátor @, kterým lze uvnitř nějaké metody (včetně konstruktoru) zajistit volání metody jiné. Pokud tedy budeme chtít z konstruktoru new volat settery, lze to zajistit jednoduše:

--
-- Skript zapsaný v jazyce Moonscript
--
 
class Customer
  new: (name, surname) =>
    @set_name(name)
    @set_surname(surname)
 
  set_name: (name) =>
    @name = name
 
  set_surname: (surname) =>
    @surname = surname
 
  get_name: =>
    @name
 
  get_surname: =>
    @surname
 
c = Customer "foo", "bar"
 
print c\get_name!
print c\get_surname!
 
c\set_name "FOO"
c\set_surname "BAR"
 
print c\get_name!
print c\get_surname!

S tímto překladem do jazyka Lua:

--
-- Skript transpilovaný do jazyka Lua
--
 
local Customer
do
  local _class_0
  local _base_0 = {
    set_name = function(self, name)
      self.name = name
    end,
    set_surname = function(self, surname)
      self.surname = surname
    end,
    get_name = function(self)
      return self.name
    end,
    get_surname = function(self)
      return self.surname
    end
  }
  _base_0.__index = _base_0
  _class_0 = setmetatable({
    __init = function(self, name, surname)
      self:set_name(name)
      return self:set_surname(surname)
    end,
    __base = _base_0,
    __name = "Customer"
  }, {
    __index = _base_0,
    __call = function(cls, ...)
      local _self_0 = setmetatable({}, _base_0)
      cls.__init(_self_0, ...)
      return _self_0
    end
  })
  _base_0.__class = _class_0
  Customer = _class_0
end
local c = Customer("foo", "bar")
print(c:get_name())
print(c:get_surname())
c:set_name("FOO")
c:set_surname("BAR")
print(c:get_name())
return print(c:get_surname())

Samozřejmě není nutné při volání metod používat kulaté závorky:

--
-- Skript zapsaný v jazyce Moonscript
--
 
class Customer
  new: (name, surname) =>
    @set_name name
    @set_surname surname
 
  set_name: (name) =>
    @name = name
 
  set_surname: (surname) =>
    @surname = surname
 
  get_name: =>
    @name
 
  get_surname: =>
    @surname
 
c = Customer "foo", "bar"
 
print c\get_name!
print c\get_surname!
 
c\set_name "FOO"
c\set_surname "BAR"
 
print c\get_name!
print c\get_surname!

Překlad bude naprosto totožný s předchozím příkladem:

--
-- Skript transpilovaný do jazyka Lua
--
 
local Customer
do
  local _class_0
  local _base_0 = {
    set_name = function(self, name)
      self.name = name
    end,
    set_surname = function(self, surname)
      self.surname = surname
    end,
    get_name = function(self)
      return self.name
    end,
    get_surname = function(self)
      return self.surname
    end
  }
  _base_0.__index = _base_0
  _class_0 = setmetatable({
    __init = function(self, name, surname)
      self:set_name(name)
      return self:set_surname(surname)
    end,
    __base = _base_0,
    __name = "Customer"
  }, {
    __index = _base_0,
    __call = function(cls, ...)
      local _self_0 = setmetatable({}, _base_0)
      cls.__init(_self_0, ...)
      return _self_0
    end
  })
  _base_0.__class = _class_0
  Customer = _class_0
end
local c = Customer("foo", "bar")
print(c:get_name())
print(c:get_surname())
c:set_name("FOO")
c:set_surname("BAR")
print(c:get_name())
return print(c:get_surname())

15. Použití programové konstrukce with

Pokud se v nějakém bloku kódu často volají metody určitého objektu, lze tento blok zjednodušit použitím programové konstrukce with. Namísto:

c = Customer "foo", "bar"
print c\get_name!
print c\get_surname!
c\set_name "FOO"
c\set_surname "BAR"
print c\get_name!
print c\get_surname!

lze psát:

with Customer "foo", "bar"
  print \get_name!
  print \get_surname!
  \set_name "FOO"
  \set_surname "BAR"
  print \get_name!
  print \get_surname!

Opět se pochopitelně podíváme na ucelený spustitelný příklad:

--
-- Skript zapsaný v jazyce Moonscript
--
 
class Customer
  new: (name, surname) =>
    @set_name name
    @set_surname surname
 
  set_name: (name) =>
    @name = name
 
  set_surname: (surname) =>
    @surname = surname
 
  get_name: =>
    @name
 
  get_surname: =>
    @surname
 
with Customer "foo", "bar"
  print \get_name!
  print \get_surname!
  \set_name "FOO"
  \set_surname "BAR"
  print \get_name!
  print \get_surname!

I na způsob jeho transpilace do programovacího jazyka Lua:

--
-- Skript transpilovaný do jazyka Lua
--
 
local Customer
do
  local _class_0
  local _base_0 = {
    set_name = function(self, name)
      self.name = name
    end,
    set_surname = function(self, surname)
      self.surname = surname
    end,
    get_name = function(self)
      return self.name
    end,
    get_surname = function(self)
      return self.surname
    end
  }
  _base_0.__index = _base_0
  _class_0 = setmetatable({
    __init = function(self, name, surname)
      self:set_name(name)
      return self:set_surname(surname)
    end,
    __base = _base_0,
    __name = "Customer"
  }, {
    __index = _base_0,
    __call = function(cls, ...)
      local _self_0 = setmetatable({}, _base_0)
      cls.__init(_self_0, ...)
      return _self_0
    end
  })
  _base_0.__class = _class_0
  Customer = _class_0
end
do
  local _with_0 = Customer("foo", "bar")
  print(_with_0:get_name())
  print(_with_0:get_surname())
  _with_0:set_name("FOO")
  _with_0:set_surname("BAR")
  print(_with_0:get_name())
  print(_with_0:get_surname())
  return _with_0
end

16. Blok do

Blok do se v jazyce Moonscript používá prakticky stejným způsobem jako v jazyce Lua, ovšem s tím (očekávaným) rozdílem, že poslední výraz je z tohoto bloku vrácen a je ho možné například přiřadit do proměnné:

--
-- Skript zapsaný v jazyce Moonscript
--
 
z = do
  x = 10
  y = 20
  x + y
 
print z

Povšimněte si, že proměnné x a y jsou lokální skutečně jen v rámci bloku do:

--
-- Skript transpilovaný do jazyka Lua
--
 
local z
do
  local x = 10
  local y = 20
  z = x + y
end
return print(z)

17. Destructuring

V některých programovacích jazycích se setkáme s termínem destructuring, kterým se většinou označuje „rozložení“ nějaké datové struktury na jednotlivé prvky a přiřazení těchto položek do proměnných (viz například jazyky Rust, Python či Clojure). Destructuring lze využít i v Moonscriptu, a to například pro uložení položek z tabulky do dvou proměnných:

foo = {1,2}
 
{x,y} = foo

V praxi, například při práci s deserializovaným JSONem, se setkáme i s destructuringem vnořených položek objektů:

obj = {
  numbers: {1,2,3,4}
}
 
{numbers: {first, second}} = obj

V tomto případě jsme získali hodnoty prvních dvou prvků z vnořené tabulky numbers a uložili jsme je do proměnných first a second.

Celý skript ukazující dvě možnosti destructuringu, lze v Moonscriptu zapsat následovně:

Linux tip

--
-- Skript zapsaný v jazyce Moonscript
--
 
foo = {1,2}
 
{x,y} = foo
print x, y
 
obj = {
  numbers: {1,2,3,4}
}
 
{numbers: {first, second}} = obj
print first, second

Z transpilovaného kódu je patrné, jak je destructuring realizován:

--
-- Skript transpilovaný do jazyka Lua
--
 
local foo = {
  1,
  2
}
local x, y
x, y = foo[1], foo[2]
print(x, y)
local obj = {
  numbers = {
    1,
    2,
    3,
    4
  }
}
local first, second
first, second = obj.numbers[1], obj.numbers[2]
return print(first, second)

18. Příloha: zápis řezu (slice) v různých programovacích jazycích

Řezy neboli slices jsou podporovány v mnoha programovacích jazycích. Syntaxe jejich zápisu se liší, stejně jako chápání (sémantika) horního indexu (tedy zda má být prvek s tímto indexem součástí řezu či nikoli). Následující tabulka ukazuje zápis řezů ve vybraných programovacích jazycích:

Syntaxe zápisu Programovací jazyk(y)
name[první,poslední] Moonscript
name[první:poslední] ALGOL 68, Julia
name[první:poslední+1:krok] Python
name[první:poslední+1] Go
name[první..poslední] Pascal, Object Pascal, Delphi, Nim
$name[první..poslední] Windows PowerShell
@name[první..poslední] Perl
name[první..poslední] Ruby
name[první…poslední+1] Ruby
name[první, délka] Ruby
name(první..poslední) Ada
name(první:poslední) Fortran, GNU Octave, MATLAB
name[[první;;poslední;;krok]] Mathematica, Wolfram Language
name.slice(první, poslední+1) Haxe, JavaScript, Scala
name[první..<poslední+1] Swift
name[první…poslední] Swift
name[první..poslední+1] D, C#
name[první..poslední+1] Rust
name[první..=poslední] Rust
name[první:poslední+1] Cobra
name.[první..krok..poslední] F#
array_slice(proměnná, první, délka) PHP

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

# 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
       
51 27_arrow_function.moon zopakování z minula – deklarace funkce operátorem šipky https://github.com/tisnik/moonscript-examples/blob/master/27_a­rrow_function.moon
52 27_arrow_function.lua transpřeklad předchozího zdrojového kódu do jazyka Lua https://github.com/tisnik/moonscript-examples/blob/master/27_a­rrow_function.lua
53 28_function_parenthesis.moon funkce volaná v pozici parametru jiné funkce a problematika závorek https://github.com/tisnik/moonscript-examples/blob/master/28_fun­ction_parenthesis.moon
54 28_function_parenthesis.lua transpřeklad předchozího zdrojového kódu do jazyka Lua https://github.com/tisnik/moonscript-examples/blob/master/28_fun­ction_parenthesis.lua
55 29_function_parenthesis.moon funkce volaná v pozici parametru jiné funkce a problematika závorek https://github.com/tisnik/moonscript-examples/blob/master/29_fun­ction_parenthesis.moon
56 29_function_parenthesis.lua transpřeklad předchozího zdrojového kódu do jazyka Lua https://github.com/tisnik/moonscript-examples/blob/master/29_fun­ction_parenthesis.lua
57 30_fat_arrow.moon operátor „tlusté šipky“, funkce bez těla https://github.com/tisnik/moonscript-examples/blob/master/30_fat_arrow.moon
58 30_fat_arrow.lua transpřeklad předchozího zdrojového kódu do jazyka Lua https://github.com/tisnik/moonscript-examples/blob/master/30_fat_arrow.lua
59 31_fat_arrow.moon operátor „tlusté šipky“, funkce s parametrem a tělem https://github.com/tisnik/moonscript-examples/blob/master/31_fat_arrow.moon
60 31_fat_arrow.lua transpřeklad předchozího zdrojového kódu do jazyka Lua https://github.com/tisnik/moonscript-examples/blob/master/31_fat_arrow.lua
61 32_fat_arrow.moon operátor „tlusté šipky“, zjednodušený přístup k atributu https://github.com/tisnik/moonscript-examples/blob/master/32_fat_arrow.moon
62 32_fat_arrow.lua transpřeklad předchozího zdrojového kódu do jazyka Lua https://github.com/tisnik/moonscript-examples/blob/master/32_fat_arrow.lua
63 33_fat_arrow.moon operátor „tlusté šipky“, zjednodušený přístup k atributu, výchozí hodnota parametru https://github.com/tisnik/moonscript-examples/blob/master/33_fat_arrow.moon
64 33_fat_arrow.lua transpřeklad předchozího zdrojového kódu do jazyka Lua https://github.com/tisnik/moonscript-examples/blob/master/33_fat_arrow.lua
65 34_multiline_arguments.moon funkce s velkým množstvím parametrů, zápis na jediném řádku https://github.com/tisnik/moonscript-examples/blob/master/34_mul­tiline_arguments.moon
66 34_multiline_arguments.lua transpřeklad předchozího zdrojového kódu do jazyka Lua https://github.com/tisnik/moonscript-examples/blob/master/34_mul­tiline_arguments.lua
67 35_multiline_arguments.moon funkce s velkým množstvím parametrů, zápis na více řádcích https://github.com/tisnik/moonscript-examples/blob/master/35_mul­tiline_arguments.moon
68 35_multiline_arguments.lua transpřeklad předchozího zdrojového kódu do jazyka Lua https://github.com/tisnik/moonscript-examples/blob/master/35_mul­tiline_arguments.lua
69 36_multiline_arguments.moon volání funkce s mnoha parametry, zápis na více řádcích https://github.com/tisnik/moonscript-examples/blob/master/36_mul­tiline_arguments.moon
70 36_multiline_arguments.lua transpřeklad předchozího zdrojového kódu do jazyka Lua https://github.com/tisnik/moonscript-examples/blob/master/36_mul­tiline_arguments.lua
71 37_multiline_arguments.moon problematika závorek při volání funkcí https://github.com/tisnik/moonscript-examples/blob/master/37_mul­tiline_arguments.moon
72 37_multiline_arguments.lua transpřeklad předchozího zdrojového kódu do jazyka Lua https://github.com/tisnik/moonscript-examples/blob/master/37_mul­tiline_arguments.lua
73 38_list_comprehension.moon generátorová notace seznamu, základní konstrukce https://github.com/tisnik/moonscript-examples/blob/master/38_lis­t_comprehension.moon
74 38_list_comprehension.lua transpřeklad předchozího zdrojového kódu do jazyka Lua https://github.com/tisnik/moonscript-examples/blob/master/38_lis­t_comprehension.lua
75 39_list_comprehension.moon generátorová notace seznamu, náhrada ipairs za * https://github.com/tisnik/moonscript-examples/blob/master/39_lis­t_comprehension.moon
76 39_list_comprehension.lua transpřeklad předchozího zdrojového kódu do jazyka Lua https://github.com/tisnik/moonscript-examples/blob/master/39_lis­t_comprehension.lua
77 40_list_comprehension.moon generátorová notace seznamu, podmínka when https://github.com/tisnik/moonscript-examples/blob/master/40_lis­t_comprehension.moon
78 40_list_comprehension.lua transpřeklad předchozího zdrojového kódu do jazyka Lua https://github.com/tisnik/moonscript-examples/blob/master/40_lis­t_comprehension.lua
79 41_list_comprehension.moon generátorová notace seznamu, kombinace předchozích možností https://github.com/tisnik/moonscript-examples/blob/master/41_lis­t_comprehension.moon
80 41_list_comprehension.lua transpřeklad předchozího zdrojového kódu do jazyka Lua https://github.com/tisnik/moonscript-examples/blob/master/41_lis­t_comprehension.lua
81 42_numeric_comprehension.moon „numerická“ generátorová notace seznamu, základní varianta https://github.com/tisnik/moonscript-examples/blob/master/42_nu­meric_comprehension.moon
82 42_numeric_comprehension.lua transpřeklad předchozího zdrojového kódu do jazyka Lua https://github.com/tisnik/moonscript-examples/blob/master/42_nu­meric_comprehension.lua
83 43_numeric_comprehension.moon „numerická“ generátorová notace seznamu https://github.com/tisnik/moonscript-examples/blob/master/43_nu­meric_comprehension.moon
84 43_numeric_comprehension.lua transpřeklad předchozího zdrojového kódu do jazyka Lua https://github.com/tisnik/moonscript-examples/blob/master/43_nu­meric_comprehension.lua
85 44_table_comprehension.moon generátorová notace tabulky https://github.com/tisnik/moonscript-examples/blob/master/44_ta­ble_comprehension.moon
86 44_table_comprehension.lua transpřeklad předchozího zdrojového kódu do jazyka Lua https://github.com/tisnik/moonscript-examples/blob/master/44_ta­ble_comprehension.lua
87 45_slicing.moon slicing prováděný v konstrukci generátorové notace seznamu https://github.com/tisnik/moonscript-examples/blob/master/45_slicing.moon
88 45_slicing.lua transpřeklad předchozího zdrojového kódu do jazyka Lua https://github.com/tisnik/moonscript-examples/blob/master/45_slicing.lua
89 46_slicing.moon slicing prováděný v konstrukci generátorové notace seznamu https://github.com/tisnik/moonscript-examples/blob/master/46_slicing.moon
90 46_slicing.lua transpřeklad předchozího zdrojového kódu do jazyka Lua https://github.com/tisnik/moonscript-examples/blob/master/46_slicing.lua
       
91 47_for_slicing.moon specifikace řezu tabulkou v programové smyčce for-each https://github.com/tisnik/moonscript-examples/blob/master/47_for_sli­cing.moon
92 47_for_slicing.lua transpřeklad předchozího zdrojového kódu do jazyka Lua https://github.com/tisnik/moonscript-examples/blob/master/47_for_sli­cing.lua
93 48_for_slicing.moon řez tabulkou v programové smyčce for-each bez uvedení dolního indexu https://github.com/tisnik/moonscript-examples/blob/master/48_for_sli­cing.moon
94 48_for_slicing.lua transpřeklad předchozího zdrojového kódu do jazyka Lua https://github.com/tisnik/moonscript-examples/blob/master/48_for_sli­cing.lua
95 49_for_slicing.moon řez tabulkou v programové smyčce for-each bez uvedení horního indexu https://github.com/tisnik/moonscript-examples/blob/master/49_for_sli­cing.moon
96 49_for_slicing.lua transpřeklad předchozího zdrojového kódu do jazyka Lua https://github.com/tisnik/moonscript-examples/blob/master/49_for_sli­cing.lua
97 50_for_slicing.moon řez tabulkou, vliv použití záporného horního indexu https://github.com/tisnik/moonscript-examples/blob/master/50_for_sli­cing.moon
98 50_for_slicing.lua transpřeklad předchozího zdrojového kódu do jazyka Lua https://github.com/tisnik/moonscript-examples/blob/master/50_for_sli­cing.lua
99 51_for_slicing.moon krok specifikovaný při řezu tabulkou https://github.com/tisnik/moonscript-examples/blob/master/51_for_sli­cing.moon
100 51_for_slicing.lua transpřeklad předchozího zdrojového kódu do jazyka Lua https://github.com/tisnik/moonscript-examples/blob/master/51_for_sli­cing.lua
101 52_for_oneline.moon programová smyčka typu for-each zapsaná na jednom programovém řádku https://github.com/tisnik/moonscript-examples/blob/master/52_for_o­neline.moon
102 52_for_oneline.lua transpřeklad předchozího zdrojového kódu do jazyka Lua https://github.com/tisnik/moonscript-examples/blob/master/52_for_o­neline.lua
103 53_for_as_value.moon počítaná programová smyčka typu for ve funkci hodnoty https://github.com/tisnik/moonscript-examples/blob/master/53_for_as_va­lue.moon
104 53_for_as_value.lua transpřeklad předchozího zdrojového kódu do jazyka Lua https://github.com/tisnik/moonscript-examples/blob/master/53_for_as_va­lue.lua
105 54_for_filter.moon realizace filtru programovou smyčkou typu for https://github.com/tisnik/moonscript-examples/blob/master/54_for_fil­ter.moon
106 54_for_filter.lua transpřeklad předchozího zdrojového kódu do jazyka Lua https://github.com/tisnik/moonscript-examples/blob/master/54_for_filter.lua
107 55_for_from_function.moon vrácení hodnot(y) generovaných smyčkou for z funkce https://github.com/tisnik/moonscript-examples/blob/master/55_for_from_fun­ction.moon
108 55_for_from_function.lua transpřeklad předchozího zdrojového kódu do jazyka Lua https://github.com/tisnik/moonscript-examples/blob/master/55_for_from_fun­ction.lua
109 56_while.moon nepatrně zjednodušený zápis programové smyčky typu while https://github.com/tisnik/moonscript-examples/blob/master/56_while.moon
110 56_while.lua transpřeklad předchozího zdrojového kódu do jazyka Lua https://github.com/tisnik/moonscript-examples/blob/master/56_while.lua
111 57_simple_class.moon deklarace třídy s konstruktorem https://github.com/tisnik/moonscript-examples/blob/master/57_sim­ple_class.moon
112 57_simple_class.lua transpřeklad předchozího zdrojového kódu do jazyka Lua https://github.com/tisnik/moonscript-examples/blob/master/57_sim­ple_class.lua
113 58_attribute_operator.moon zjednodušený přístup k atributům objektů pomocí operátoru @ https://github.com/tisnik/moonscript-examples/blob/master/58_at­tribute_operator.moon
114 58_attribute_operator.lua transpřeklad předchozího zdrojového kódu do jazyka Lua https://github.com/tisnik/moonscript-examples/blob/master/58_at­tribute_operator.lua
115 59_methods.moon volání metod objektu s využitím operátoru \ https://github.com/tisnik/moonscript-examples/blob/master/59_methods.moon
116 59_methods.lua transpřeklad předchozího zdrojového kódu do jazyka Lua https://github.com/tisnik/moonscript-examples/blob/master/59_methods.lua
117 60_methods.moon metody bez parametrů a s jednopříkazovým tělem https://github.com/tisnik/moonscript-examples/blob/master/60_methods.moon
118 60_methods.lua transpřeklad předchozího zdrojového kódu do jazyka Lua https://github.com/tisnik/moonscript-examples/blob/master/60_methods.lua
119 61_constructor.moon předání parametrů konstruktoru objektu https://github.com/tisnik/moonscript-examples/blob/master/61_con­structor.moon
120 61_constructor.lua transpřeklad předchozího zdrojového kódu do jazyka Lua https://github.com/tisnik/moonscript-examples/blob/master/61_con­structor.lua
121 62_constructor.moon volání metod přímo z konstruktoru https://github.com/tisnik/moonscript-examples/blob/master/62_con­structor.moon
122 62_constructor.lua transpřeklad předchozího zdrojového kódu do jazyka Lua https://github.com/tisnik/moonscript-examples/blob/master/62_con­structor.lua
123 63_constructor.moon zjednodušený zápis bez závorek https://github.com/tisnik/moonscript-examples/blob/master/63_con­structor.moon
124 63_constructor.lua transpřeklad předchozího zdrojového kódu do jazyka Lua https://github.com/tisnik/moonscript-examples/blob/master/63_con­structor.lua
125 64_with.moon použití programové konstrukce with https://github.com/tisnik/moonscript-examples/blob/master/64_with.moon
126 64_with.lua transpřeklad předchozího zdrojového kódu do jazyka Lua https://github.com/tisnik/moonscript-examples/blob/master/64_with.lua
127 65_do.moon blok do s návratovou hodnotou https://github.com/tisnik/moonscript-examples/blob/master/65_do.moon
128 65_do.lua transpřeklad předchozího zdrojového kódu do jazyka Lua https://github.com/tisnik/moonscript-examples/blob/master/65_do.lua
129 66_destructuring.moon destructuring v jazyce Moonscript https://github.com/tisnik/moonscript-examples/blob/master/66_des­tructuring.moon
130 66_destructuring.lua transpřeklad předchozího zdrojového kódu do jazyka Lua https://github.com/tisnik/moonscript-examples/blob/master/66_des­tructuring.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
  45. Assignment (computer science)
    https://en.wikipedia.org/wi­ki/Assignment_(computer_sci­ence)
  46. Destructuring in Clojure
    https://clojure.org/guides/des­tructuring
  47. Should Array Index Start at 0 or 1?
    http://xahlee.info/comp/com­p_lang_array_index_start0_or.html
  48. Programming Languages where indices start from 1 (NOT 0)
    https://iq.opengenus.org/array-indices-start-from-1/
  49. Comparison of programming languages (array)
    https://en.wikipedia.org/wi­ki/Comparison_of_programmin­g_languages_(array)#Indexing

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.