Uiua: nevšední kombinace zásobníkového jazyka s jazykem pro práci s poli

Obsah

1. Mainstreamové, ne-mainstreamové a esoterické programovací jazyky

2. Uiua: nevšední kombinace zásobníkového jazyka s jazykem pro práci s poli

3. Základní koncepty, na nichž je programovací jazyk Uiua postaven

4. Programovací jazyky založené na zásobníku operandů a RPN

5. Použití zásobníku v programovacím jazyku Uiua

6. Funkce pro manipulace s prvky uloženými na zásobníku

7. Základní monadické funkce pro zpracování skalárních hodnot

8. Základní dyadické funkce pro zpracování skalárních hodnot

9. Pole

10. Konstrukce polí

11. Zpracování polí prvek po prvku

12. Monadické funkce pro operace nad celými poli

13. Ukázka použití vybraných monadických funkcí

14. Dyadické funkce pro operace nad celými poli

15. Ukázka použití vybraných dyadických funkcí

16. Agregační operace

17. Iterace nad prvky polí

18. Závěr

19. Předchozí články o rozsáhlém světu „array programmingu“

20. Odkazy na Internetu

1. Mainstreamové, ne-mainstreamové a esoterické programovací jazyky

Na stránkách Roota jsme se již mohli seznámit s různými programovacími jazyky. Jednalo se jak o programovací jazyky patřící spíše do mainstreamu (do této kategorie si v současnosti dovolím zařadit Rust i Go), tak i o programovací jazyky velmi specializované (Julia či R). A zapomenout nesmíme ani na různé více či méně esoterické programovací jazyky, o nichž jsme psali v seriálu Programovací jazyky z vývojářského pekla.

Minimálně dvě skupiny programovacích jazyků, s nimiž jsme se prozatím seznámili, nepatří (alespoň nikoli v současnosti) mezi mainstream. V první skupině nalezneme jazyky založené na použití dvojice zásobníků (konkrétně na zásobníku operandů a na zásobníku návratových hodnot). Mezi tyto jazyky patří především programovací jazyk Forth, ale například taktéž jazyky Joy a Factor, které jsou Forthem jasně inspirovány. A druhou skupinou ne-mainstreamových programovacích jazyků tvoří jazyky specializované pro práci s n-rozměrnými poli, tedy zejména APL, J, BQN, K, Q či jazyk Nial.

2. Uiua: nevšední kombinace zásobníkového jazyka s jazykem pro práci s poli

V dnešním článku se ve stručnosti seznámíme s programovacím jazykem, který je možné zařadit jak mezi jazyky zásobníkové (tedy patřící do „Forthovské“ skupiny), tak i mezi jazyky určené pro práci s n-rozměrnými poli (jde tedy o „APL“ skupinu). Tento neobvyklý programovací jazyk, jehož syntaxe a sémantika je poněkud esoterická, má i dosti prapodivné jméno – Uiua (vyslovováno má být jako wee-wuh). Mohlo by se zdát, že propojení zásobníkového jazyka s jazykem pro práci s n-rozměrnými poli je poněkud umělé, ale výsledek je až překvapivě konzistentní, i když bez předchozího tréninku pochopitelně velmi špatně čitelný. Navíc je díky syntaxi zápisu umožněn a podporován tacit programming neboli point-free style, což je způsob programování bez nutnosti explicitního pojmenovávání předávaných parametrů, jemuž jsme se věnovali v článku Jazyk APL, kombinátory, vláčky a point-free style (a který je vlastně implicitně podporován prakticky všemi zásobníkovými jazyky).

3. Základní koncepty, na nichž je programovací jazyk Uiua postaven

Programovací jazyk Uiua je postaven na několika konceptech, s nimiž se podrobněji setkáme v navazujících kapitolách:

1. Prvním konceptem je fakt, že operandy jsou ukládány na zásobník (stack). Zásobník zde funguje stejně, jako je tomu v mnoha klasických zásobníkových jazycích, tj. poslední prvek vložený na zásobník je umístěn na vrchol zásobníku (TOS – Top of Stack) a taktéž je jako první ze zásobníku vyjmut. Jinými slovy – jedná se o datovou struktury typu LIFO – Last In, First Out.
2. Další koncept spočívá ve způsobu zpracování jednotlivých programových řádků po jejich parsingu. Operandy, funkce a modifikátory, jsou totiž čteny zprava doleva (ano, čtete správně – zprava doleva). Pokud je nalezen operand (hodnota), je uložen na zásobník, funkce své operandy čtou ze zásobníku a modifikátory mění chování funkcí. Tím je vlastně popsána celá sémantika :-)
3. Operandy jsou jen dvou typů – skaláry a pole.
4. Funkce mohou být monadické (s jedním operandem) nebo dyadické (se dvěma operandy). Ovšem teoreticky lze díky použití zásobníku mít i funkce s větším počtem operandů (na rozdíl od APL, kde je to minimálně problematické až nemožné).
5. Funkce, které pracují se skaláry, dokážou postupně zpracovat i prvky pole či odpovídající si prvky pole (například součet polí je realizován prvek po prvku).
6. Poté existují funkce pracující pouze s poli. Příkladem je funkcereshape, kterou nemá smysl aplikovat na skalární hodnotu.
7. V jazyku lze nalézt i takzvané modifikátory, kam spadají například operace reduce, fold či scan apod. Jedná se o nejsilnější koncept tohoto jazyka (převzatý z APL).
8. A nakonec se v jazyku nachází „podivnosti“ nazvané Planet a Ocean (viz závěrečné kapitoly).

Obrázek 1: Interaktivní webové prostředí programovacího jazyka Uiua. V současnosti si lze základní vlastnosti většiny programovacích jazyků ověřit právě v různých webových prostředích, takže není vyžadována (mnohdy zbytečně komplikovaná) instalace.

4. Programovací jazyky založené na zásobníku operandů a RPN

V úvodním textu jsme se zmínili o programovacích jazycích Forth, Joy, Factor (ale patří sem například i PostScript). I přesto, že se tyto programovací jazyky od sebe v mnoha ohledech odlišují, mají jednu důležitou vlastnost společnou – výpočty, tj. aritmetické operace, logické operace a v neposlední řadě i rozhodovací (řídicí) konstrukce jsou prováděny s hodnotami uloženými na zásobníku (ten je z tohoto důvodu nazýván zásobník operandů). Díky tomu bylo možné tyto programovací jazyky interně značně zjednodušit, protože se o transformaci výrazů z dnes běžné infixové podoby do podoby postfixové (jinak známé pod názvem převrácená polská notace/Reverse Polish Notation, Reverse Polish Notation – RPN) musí postarat sám programátor. To ve skutečnosti není nijak složité, ostatně s prakticky stejným (pseudo)problémem se musí potýkat i ti uživatelé, kteří například používají kalkulačky vyráběné společností Hewlett-Packard.

Obrázek 2: I moderní kalkulačky vyráběné společností Hewlett-Packard podporují převrácenou polskou notaci.

V této kapitole si jen v krátkosti připomeňme, že při použití zásobníku operandů přímo v programovacím jazyku jsou hodnoty na zásobník ukládány explicitně (zápis 42 tedy většinou znamená uložení této hodnoty na vrchol zásobníku operandů), aritmetické a logické operace používají implicitní adresování operandů (vždy se totiž jedná o hodnotu uloženou na vrcholu zásobníku či těsně pod ním) a kromě toho se většinou setkáme i s několika pomocnými operacemi určenými pro manipulaci s obsahem zásobníku. Tyto operace bývají nazývány dup (zduplikování hodnoty uložené na vrcholu zásobníku, zásobník se o jeden prvek zvětší), drop (odstranění hodnoty z vrcholu zásobníku operandů, zásobník se o jeden prvek zmenší), swap (prohození dvou nejvyšších prvků uložených na zásobníku, velikost zásobníku se nezmění) a rot (rotace tří nejvyšších prvků, velikost zásobníku se opět nezmění). Tyto názvy mají dnes již vlastně historický původ, protože byly použity v programovacím jazyku Forth; později se začaly používat například i v zásobníkových virtuálních strojích.

Nicméně se vraťme k zásobníku operandů a k tacit programmingu. Ve Forthu je možné napsat například následující funkci:

:foo + * ;

Tato funkce na zásobníku očekává alespoň tři číselné hodnoty, které ovšem uvnitř funkce nejsou nikde explicitně pojmenovány ani (explicitně) použity. Použití této funkce je stejně snadné jako její zápis, pochopitelně pokud si zvyknete na RPN:

3 2 1 foo .
9

Nejprve jsme na zásobník uložili tři hodnoty. Posléze se zavolala funkce foo, která tyto hodnoty nějakým způsobem zpracovala. Na nakonec byla hodnota umístěná na TOS vypsána další funkcí se jménem . (ano, tečka je ve Forthu skutečně zcela legitimní jméno funkce).

Povšimněte si, že nyní těla funkce foo:

+ *

Tělo této funkce obsahuje pouze dvě tzv. slova „+“ a „*“. Každé z těchto slov očekává na zásobníku operandů dvojici hodnot, které jsou sečteny, popř. vynásobeny a výsledek je uložen zpět na zásobník operandů. Nikde tedy není nutné psát, jak se operandy jmenují a už vůbec ne, jak se jmenuje výsledná hodnota. Navíc ani funkce foo tyto údaje neobsahuje.

5. Použití zásobníku v programovacím jazyku Uiua

Všechny dále uvedené příklady si můžeme vyzkoušet na adrese https://www.uiua.org/ přímo v interaktivním prostředí pracujícím ve webovém prohlížeči.

Obrázek 3: Nastavení, které je nutné provést v interaktivním vývojovém prostředí jazyka Uiua tak, aby se obsah zásobníku zobrazoval způsobem, který dává zkratce TOS význam.

V programovacím jazyku Uiua se nepoužívá klasická a standardní převrácená polská notace (tedy již popsaná RPN) ale určitá obdoba (přímé) polské notace, což může být poměrně matoucí. Navíc se operátory a operandy zapsané na řádku zpracovávají zprava doleva. To má sice své logické důvody, o nichž se zmíníme dále, ovšem opět se jedná o koncept, který může být dosti nezvyklý. Jak se ale tyto dvě vlastnosti, resp. jejich kombinace, projeví v praxi? Pokud například na jediný řádek zapíšeme trojici číselných hodnot, budou tyto hodnoty uloženy na zásobník (až potud je vše očekávatelné). Ovšem číselné hodnoty jsou zpracovávány zprava doleva a právě v tomto pořadí jsou uloženy na zásobník. Výsledkem tedy bude, že první zapsaná hodnota bude uložena na vrchol zásobníku operandů, tedy zcela opačně, než je tomu v klasické RPN:

1 2 3
 
1
2
3

Povšimněte si, že po spuštění výše uvedeného programu (ten je zapsán tučně) se v interaktivním prostředí pod programem zobrazí trojice hodnot tak, jak jsou uloženy na zásobníku. Vzhledem ke způsobu vyhodnocování zprava doleva se tedy na zásobník nejprve uloží hodnota 3, poté hodnota 2 a nakonec bude na vrchol zásobníku bude uložena hodnota 1.

Můžeme si otestovat i nepatrně odlišný program, po jehož spuštění se nejdříve na zásobník uloží hodnoty 2 a 1 (přesně v tomto pořadí) a následně se tyto hodnoty sečtou spuštěním operace +, která ze zásobníku vyjme dva prvky, sečte je a na zásobník vrátí výsledek součtu:

+ 1 2
 
3

Operace + ovšem ve skutečnosti pracuje pouze se dvěma nejvyššími prvky uloženými na zásobníku. Případné další prvky nejsou dotčeny:

+ 1 2 100 100
 
3
100
100

Operátor zapsaný zcela nalevo bude proveden nejpozději, což zde konkrétně znamená, že vynásobí hodnoty 3 a 100, přičemž výsledek opět uloží zpět na zásobník:

× + 1 2 100 100
 
300
100

Infixově zapsaná operace (1+2)×3 vypadá v pojetí programovacího jazyka Uiua následovně:

× + 1 2 3
 
9

Nebo též:

× 3 + 1 2
 
9

Ovšem nic nám nebrání v zápisu přes více řádků:

+ 1 2
× 3
 
9

nebo:

1 2 3
×+
 
9

či dokonce:

1 2 3
+
×
 
9

6. Funkce pro manipulace s prvky uloženými na zásobníku

V programovacím jazyku Uiua existuje šest funkcí, které jsou určeny pro manipulace s prvky uloženými na zásobníku. Některé z těchto funkcí známe již z popisu zásobníkových programovacích jazyků, ovšem poslední dvě funkce jsou specifické pro Uiua. A pochopitelně, díky tomu, že se jedná o jazyk odvozený od APL, jsou všechny funkce reprezentovány jednoznakovými symboly (z Unicode):

Otestování základního chování těchto funkcí:

Duplikace prvku na TOS:

. 1 2 3
 
1
1
2
3

Duplikace prvku pod TOS:

, 1 2 3
 
2
1
2
3

Prohození dvou nejvyšších prvků na zásobníku:

: 1 2 3
 
2
1
3

Odstranění nejvyššího prvku z TOS:

; 1 2 3
 
2
3

Změna znaménka u prvních dvou prvků:

∩¯ 1 2 3
 
¯1
¯2
3

Výpis podrobnějších informací o prvku s hodnotou –1:

⸮∩¯ 1 2 3
 
┌╴1:1
├╴¯1
└╴╴╴╴
¯1
¯2
3

7. Základní monadické funkce pro zpracování skalárních hodnot

Připomeňme si, že v programovacích jazycích odvozených od APL se rozlišuje mezi funkcemi monadickými a dyadickými. Monadické funkce mají pouze jeden operand (či parametr), kdežto dyadické funkce mají dva operandy (parametry). Nejprve si tedy popišme tu nejjednodušší skupinu funkcí. Jedná se o monadické funkce určené pro zpracování skalárních hodnot:

Několik příkladů (již bez popisu):

± 42
 
1

¯ 42
 
¯42

⌵¯42
 
42

√⌵¯100
 
10

⌊1.5
 
1

⌈1.5⌊
 
2

8. Základní dyadické funkce pro zpracování skalárních hodnot

V programovacím jazyku Uiua nalezneme i dyadické funkce, které jsou určené pro zpracování skalárních hodnot. Tyto funkce ze zásobníku získají dva prvky, provedou s nimi vybranou operaci a výsledek nebo výsledky uloží zpět na zásobník. Jedná se o následující funkce:

U některých výše zmíněných operací je nutné si dát pozor na pořadí operandů uložených na zásobníku:

÷ 1 2
 
2

÷ 2 1
 
0.5

Logaritmus o zvoleném základu:

ₙ 10 10000
 
4

ₙ 10000 10
 
0.25

9. Pole

V programovacím jazyku Uiua se primárně rozlišují dvě skupiny typů hodnot. První skupinu tvoří atomy (atom), druhou skupinu pak pole (array). Na pole se můžeme dívat jako na skupinu atomů organizovaných podél os (axes), přičemž počet os určuje dimenzi pole. Každé pole má svůj tvar, který popisuje velikost pole měřenou podél jednotlivých os (tedy pole s tvarem [2 3 4] má rozměry 2×3×4 prvky). Os přitom může být (prakticky) libovolný počet. Další důležitou vlastností polí je, že jsou homogenní, tj. obsahují prvky stejného typu.

Pole lze ukládat na zásobník, stejně jako skalární hodnoty. A navíc platí, že monadické a dyadické funkce popsané v předchozích kapitolách, lze aplikovat i na pole – potom se takové funkce buď aplikují na všechny prvky pole (monadické funkce) nebo na všechny odpovídající si prvky ze dvou polí (dyadické funkce).

10. Konstrukce polí

V programovacím jazyku Uiua existuje literál představující celé pole. Tento literál se zapisuje formou hodnot jednotlivých prvků (musí se jednat o hodnoty), které jsou spojeny (či odděleny – záleží na úhlu pohledu) podtržítkem. Literál představující jednorozměrné pole se čtyřmi prvky se zapíše takto:

1_2_3_4
 
[1 2 3 4]

Můžeme také použít konstruktor pole, v němž se jednotlivé prvky zapisují do hranatých závorek a odděleny jsou nějakým bílým znakem:

[1 2 3 4]
 
[1 2 3 4]

V tomto případě jsou ovšem prvky vyhodnocovány (nejde o literál) a to nám například umožňuje provést výpočet 1+2 a 3+4 s tím, že výsledky těchto výpočtů budou zapsány do nově zkonstruovaného pole:

[+ 1 2 + 3 4]
 
[3 7]

Konstrukce vícerozměrného pole je snadná – prvky n-rozměrného pole jsou totiž n-1 rozměrná pole, takže použijeme konstruktor, kterému tato menší pole předáme:

[[1 2][3 4]]
 
╭─
╷ 1 2
  3 4
      ╯

A takto vypadá konstrukce trojrozměrného pole:

[[[0 0][0 0]][[1 2][3 4]]]
 
╭─
╷ 0 0
╷ 0 0

  1 2
  3 4
      ╯

Jazyk Uiua pracuje i s řetězci. Řetězcový skalár se zapíše následovně:

"Hello world"
 
"Hello world"

Literál představující pole obsahující řetězce:

"Hello"_"world"
 
╭─
╷ "Hello"
  "world"
          ╯

Výsledné pole ovšem musí být homogenní – všechny prvky musí být stejného typu:

"Hello"_"world"_42
 
Error: Cannot append character array to number array
  at 1:1
1 | "Hello"_"world"_4

11. Zpracování polí prvek po prvku

Jak již víme z předchozího textu, lze všechny monadické a dyadické funkce určené pro práci se skaláry použít i pro dvojici stejně velkých polí (tedy polí se shodným tvarem). Takové funkce jsou aplikovány na odpovídající si prvky polí.

Součet dvou polí prvek po prvku:

+ [1 2 3] [4 5 6]
 
[5 7 9]

Takzvaný broadcasting umožňující přičíst hodnotu 10 ke každému prvku pole:

+ [1 2 3] 10
 
[11 12 13]

Výsledkem této operace je pole s pravdivostními hodnotami reprezentovanými jako 1 a 0:

≠ [1 2 3] 2
 
[1 0 1]

Porovnání polí prvek po prvku, výsledkem je opět pole (se shodným tvarem) obsahující výsledky porovnání:

≤ [1 2 3 4] [4 3 2 1]
 
[0 0 1 1]

Tvary polí (shape) ovšem musí být shodné:

≤ [1 2 3 4] [4 3 2 1 0]
 
Error: Shapes [4] and [5] do not match
  at 1:1
1 | ≤ [1 2 3 4] [4 3 2 1 0]

Součet dvou (dvourozměrných) matic:

+ [[1 2][3 4]] [[5 6][7 8]]
 
╭─
╷  6  8
  10 12
        ╯

12. Monadické funkce pro operace nad celými poli

V jazyku Uiua jsou realizovány i funkce, které pracují nad celými poli (nikoli tedy nutně prvek po prvku). Tyto funkce jsou vypsány v následující tabulce:

13. Ukázka použití vybraných monadických funkcí

Podívejme se nyní na způsob použití několika vybraných monadických funkcí určených pro zpracování celých polí.

Délka pole – počet prvků v nejvyšší dimenzi:

⧻ [[1 2][3 4]]
 
2

Získání tvaru (shape) pole:

△ [[1 2][3 4]]
 
[2 2]

Vygenerování vektoru obsahujícího sekvenci hodnot od 0 do 9:

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

Získání pole pravdivostních hodnot (reprezentovaných nulami a jedničkami) na základě porovnání prvku každého pole s konstantou 4:

≤ 4 ⇡ 10
 
[1 1 1 1 1 0 0 0 0 0]

Otočení pole vytvořeného funkcí range:

⇌ ⇡ 10
 
[9 8 7 6 5 4 3 2 1 0]

Deshape pole – převod na jednorozměrný vektor:

♭ [[1 2][3 4][5 6]]
 
[1 2 3 4 5 6]

Kombinace funkce pro převod pole na jednorozměrný vektor s funkcí pro otočení prvků pole:

⇌♭ [[1 2][3 4][5 6]]
 
[6 5 4 3 2 1]

14. Dyadické funkce pro operace nad celými poli

Další funkce jsou dyadické, přičemž jedním z parametrů je v tomto případě pole (a druhým parametrem může být skalár nebo taktéž pole). Jedná se o následující funkce:

15. Ukázka použití vybraných dyadických funkcí

Opět se podívejme na využití vybraných dyadických funkcí určených pro práci s poli.

Spojení dvou polí funkcí couple:

⊟ [1 2 3 4] [5 6 7 8]
 
╭─
╷ 1 2 3 4
  5 6 7 8
          ╯

Spojení dvou polí funkcí join:

⊂ [1 2 3 4] [5 6 7 8]
 
[1 2 3 4 5 6 7 8]

Výběr prvků ze druhého pole pomocí indexů v poli prvním:

⊏ [1 2 3 1 2 3] [5 6 7 8]
 
[6 7 8 6 7 8]

Změna tvaru pole (reshape):

↯ [2 3] [1 2 3 4 5 6]
 
╭─
╷ 1 2 3
  4 5 6
        ╯

Změna tvaru pole (reshape):

↯ [3 2] [1 2 3 4 5 6]
 
╭─
╷ 1 2
  3 4
  5 6
      ╯

16. Agregační operace

Programovací jazyk Uiua však kromě poměrně rozsáhlé řady primitivních funkcí obsahuje, ostatně podobně jako již popsaný jazyk APL, několik operátorů, pomocí nichž jsou funkce aplikovány nikoli na jeden či dva parametry, ale postupně na celé vektory nebo matice (proto se nazývají agregační operace). Díky operátorům (význam tohoto slova je odlišný od významu, který toto slovo má v jiných programovacích jazycích!) je možné eliminovat velké množství programových smyček a mnohdy tak například několikařádkovou proceduru zapsat pomocí jediného výrazu:

17. Ukázka použití základních agregačních operací

Jedním z nejdůležitějších operátorů jazyka Uiua je operátor /, který jsme si již v jednodušší podobě představili při popisu jazyka APL. Tento operátor, který se zapisuje před identifikátor primitivní či uživatelské funkce, postupně danou funkci aplikuje na první dva prvky argumentu, dále ji aplikuje na průběžný výsledek a třetí prvek atd., do doby, než jsou všechny prvky argumentu zpracovány (jinými slovy – daná dyadická funkce je jakoby zapsána mezi všechny prvky předané datové struktury, počet operací je roven n-1 v případě, že předaný vektor má počet prvků n):

Součet všech prvků pole:

/+ [1 2 3 4]
 
10

Součet hodnot od 1 do 9:

/+ ⇡10
 
45

Výpočet faktoriálu 10:

/× +1 ⇡10
 

Mezery nejsou nezbytné:

/×+1⇡10
 
3628800

Ovšem v některých případech může být lepší použití fold se specifikací prvního prvku:

∧× [1 2 3 4] 10
 
240

Lze zkombinovat s počátečním prvkem, který je polem:

∧× [1 2 3 4] [1 2 10]
 
[24 48 240]

Dalším dobrým příkladem může být modifikátor nazvaný scan, který postupně prochází všemi prvky, aplikuje zvolenou funkci na aktuální prvek a akumulátor a na vstup posílá výsledek zvolené funkce. Jedná se tedy o obdobu funkce reduction z jazyka APL.

Výčet tabulky faktoriálů operátorem scan (opět zapsáno bez mezer):

\×+1⇡10
 
[1 2 6 24 120 720 5040 40320 362880 3628800]

A konečně si ukažme outer product. S využitím tohoto operátoru je možné zkonstruovat velké množství matic se speciálními vlastnostmi; tyto matice mohou mít samozřejmě téměř libovolnou velikost. Jedná se například o jednotkové matice (obsahují jedničky v diagonále, ostatní prvky jsou nulové), trojúhelníkové matice různého typu (jedničky se nachází pod či nad diagonálou, ostatní prvky jsou nulové) atd. Tvorba těchto matic je ilustrována na následujících příkladech, ve kterých se často používají porovnávací (relační) funkce:

⊞= ⇡10 ⇡10
 
╭─
╷ 1 0 0 0 0 0 0 0 0 0
  0 1 0 0 0 0 0 0 0 0
  0 0 1 0 0 0 0 0 0 0
  0 0 0 1 0 0 0 0 0 0
  0 0 0 0 1 0 0 0 0 0
  0 0 0 0 0 1 0 0 0 0
  0 0 0 0 0 0 1 0 0 0
  0 0 0 0 0 0 0 1 0 0
  0 0 0 0 0 0 0 0 1 0
  0 0 0 0 0 0 0 0 0 1
                      ╯

⊞≤ ⇡10 ⇡10
 
╭─
╷ 1 0 0 0 0 0 0 0 0 0
  1 1 0 0 0 0 0 0 0 0
  1 1 1 0 0 0 0 0 0 0
  1 1 1 1 0 0 0 0 0 0
  1 1 1 1 1 0 0 0 0 0
  1 1 1 1 1 1 0 0 0 0
  1 1 1 1 1 1 1 0 0 0
  1 1 1 1 1 1 1 1 0 0
  1 1 1 1 1 1 1 1 1 0
  1 1 1 1 1 1 1 1 1 1
                      ╯

Malá násobilka:

⊞× +1⇡10 +1⇡10
 
╭─
╷  1  2  3  4  5  6  7  8  9  10
   2  4  6  8 10 12 14 16 18  20
   3  6  9 12 15 18 21 24 27  30
   4  8 12 16 20 24 28 32 36  40
   5 10 15 20 25 30 35 40 45  50
   6 12 18 24 30 36 42 48 54  60
   7 14 21 28 35 42 49 56 63  70
   8 16 24 32 40 48 56 64 72  80
   9 18 27 36 45 54 63 72 81  90
  10 20 30 40 50 60 70 80 90 100
                                 ╯

18. Závěr

Už z předchozího popisu je pravděpodobně zřejmé, že se programovací jazyk Uiua pravděpodobně nedostane do mainstreamu a dokonce je nepravděpodobné, že začne být ve větší míře používán v nice array programmingu (kde se dnes používá především Dyalog APL a poté jazyky K a Q, jenž jsou vyvíjeny společností Kx pro sice poměrně velký, ale dosti specifický sektor). Na druhou stranu je zajímavé, jak lze s využitím zásobníku a operací nad poli vytvořit programovací jazyk, v němž lze velmi snadno realizovat point-free styl (tacit programming). A jen na okraj: poslední dobou vznikly minimálně dva jazyky pro niku array programmingu. Je to právě Uiua, ale taktéž programovací jazyk BQN, který je postaven na myšlenkách APL, ovšem má některé základní koncepty promyšlenější (a možná tak představuje nejlepší cestu do světa array processingu).

19. Předchozí články o rozsáhlém světu „array programmingu“

Programovacími jazyky, které jsou z větší či menší míry odvozeny od programovacího jazyka APL, jsme se již na stránkách Roota zabývali v několika článcích (a samozřejmě i v dnešním článku). Odkazy na tyto články naleznete pod odstavcem:

1. Jazyky umožňující operace s poli aneb rozsáhlý svět „array programmingu“
   https://www.root.cz/clanky/jazyky-umoznujici-operace-s-poli-aneb-rozsahly-svet-bdquo-array-programmingu-ldquo/
2. Specializované jazyky pro práci s N-dimenzionálními poli: jazyk J
   https://www.root.cz/clanky/spe­cializovane-jazyky-pro-praci-s-n-dimenzionalnimi-poli-jazyk-j/
3. Programovací jazyky odvozené od APL: BQN a ivy aneb 1~×`1↓↕10
   https://www.root.cz/clanky/pro­gramovaci-jazyky-odvozene-od-apl-bqn-a-ivy-aneb-1–1–10/
4. Programovací jazyk K: důkaz, že mezi námi žijí mimozemšťané
   https://www.root.cz/clanky/pro­gramovaci-jazyk-k-dukaz-ze-mezi-nami-ziji-mimozemstane/
5. Programovací jazyk K: důkaz, že mezi námi žijí mimozemšťané (dokončení)
   https://www.root.cz/clanky/pro­gramovaci-jazyk-k-dukaz-ze-mezi-nami-ziji-mimozemstane-dokonceni/
6. Nial Array Language: další z jazyků inspirovaných APL
   https://www.root.cz/clanky/nial-array-language-dalsi-z-jazyku-inspirovanych-apl/
7. Programování mainframů: jazyk APL
   https://www.root.cz/clanky/pro­gramovani-mainframu-jazyk-apl/
8. Programovací jazyk APL: programování bez smyček
   https://www.root.cz/clanky/pro­gramovaci-jazyk-apl-programovani-bez-smycek/
9. Programovací jazyk APL – dokončení
   https://www.root.cz/clanky/pro­gramovaci-jazyk-apl-dokonceni/
10. Oslava 55 let od vzniku první implementace jazyka APL
    https://www.root.cz/clanky/oslava-55-let-od-vzniku-prvni-implementace-programovaciho-jazyka-apl/
11. Jazyk APL, kombinátory, vláčky a point-free style
    https://www.root.cz/clanky/jazyk-apl-kombinatory-vlacky-a-point-free-style/

20. Odkazy na Internetu

1. Seriál: programovací jazyk Rust
   https://www.root.cz/seria­ly/programovaci-jazyk-rust/
2. Seriál: programovací jazyk Go
   https://www.root.cz/seria­ly/programovaci-jazyk-go/
3. Seriál: programovací jazyk Julia
   https://www.root.cz/seria­ly/programovaci-jazyk-julia/
4. Seriál: programovací jazyk R
   https://www.root.cz/seria­ly/programovaci-jazyk-r/
5. Uiua: A stack-based array programming language
   https://www.uiua.org/
6. uiua na GitHubu
   https://github.com/uiua-lang/uiua
7. Nial: A powerful, interactive array language with support for flexible multiparadigm code
   https://www.nial-array-language.org/
8. Nial: dokumentace
   https://www.nial-array-language.org/ndocs/
9. Nial na GitHubu
   https://github.com/niallan­g/Nial_Development
10. Nial na Rosetta Code
    https://rosettacode.org/wi­ki/Category:Nial
11. Array language comparisons
    https://github.com/codereport/array-language-comparisons
12. K language – an introduction
    http://www.math.bas.bg/ban­tchev/place/k.html
13. K7 Tutorial
    https://cs.nyu.edu/~shasha/pa­pers/tutorial
14. An Interview with Arthur Whitney, Kx CEO and Developer of Kx Technology, January 4, 2004
    https://web.archive.org/web/20150813004101/htt­p://kx.com/arthur-interview.php
15. A Shallow Introduction to the K Programming Language
    https://web.archive.org/web/20130801233812/htt­p://www.kuro5hin.org/story/2002/11/14/22741/791
16. A Conversation with Arthur Whitney
    https://queue.acm.org/deta­il.cfm?id=1531242
17. Anecdote about Arthur Whitney
    https://news.ycombinator.com/i­tem?id=13590065
18. K – list of idioms
    https://github.com/kevinlaw­ler/kona/wiki/Idioms
19. Appendix A. Incunabulum
    http://keiapl.org/rhui/re­member.htm#incunabulum
20. K code study
    https://docs.google.com/do­cument/d/1W83ME5JecI2hd5hA­UqQ1BVF32wtCel8zxb7WPq-D4f8/edit
21. K tutorial
    https://github.com/kevinlaw­ler/kona/wiki/Tutorial
22. K by EXAMPLE
    http://vrabi.web.elte.hu/k/kbyeg.k
23. BQN: An APL Variant from Marshall Lochbaum (mlochbaum.github.io)
    https://news.ycombinator.com/i­tem?id=24167804
24. Raytracer in 7 lines in K
    http://www.nsl.com/k/ray/ray.k
25. Marshall Lochbaum
    https://www.aplwiki.com/wi­ki/Marshall_Lochbaum
26. BQN
    https://www.aplwiki.com/wiki/BQN
27. Co-dfns
    https://www.aplwiki.com/wiki/Co-dfns
28. Array model
    https://www.aplwiki.com/wi­ki/Array_model#Based_arra­y_theory
29. Fonts for BQN
    https://mlochbaum.github.i­o/BQN/fonts.html
30. Leading axis theory
    https://www.aplwiki.com/wi­ki/Leading_axis_theory
31. A based system for general arrays
    https://dl.acm.org/doi/ab­s/10.1145/586656.586663
32. APL – A Glimpse of Heaven (2006)
    https://news.ycombinator.com/i­tem?id=19325361
33. APL and J
    https://crypto.stanford.e­du/~blynn/c/apl.html
34. ivy (dokumentace)
    https://pkg.go.dev/robpike­.io/ivy#section-readme
35. ivy na GitHubu
    https://github.com/robpike/ivy/
36. Ivy na APL wiki
    https://aplwiki.com/wiki/Ivy
37. Implementing a bignum calculator (slajdy)
    https://talks.godoc.org/git­hub.com/robpike/ivy/talks/i­vy.slide#1
38. Implementing a bignum calculator – Rob Pike – golang-syd November 2014
    https://www.youtube.com/wat­ch?v=PXoG0WX0r_E
39. Rob Pike na Wikipedii
    https://en.wikipedia.org/wi­ki/Rob_Pike
40. Rob Pike na cat-v
    http://genius.cat-v.org/rob-pike/
41. NuVoc
    https://code.jsoftware.com/wiki/NuVoc
42. J (programming language) [Wikipedia]
    https://en.wikipedia.org/wi­ki/J_%28programming_langu­age%29
43. J – Absolutely Essential Terms
    https://code.jsoftware.com/wi­ki/Vocabulary/AET
44. J – Atoms and Arrays
    https://code.jsoftware.com/wi­ki/Vocabulary/Nouns#Atom
45. Why J
    https://www.jsoftware.com/hel­p/primer/why_j.htm
46. What is an Array?
    https://vector.org.uk/what-is-an-array/
47. Comments
    http://www.gavilan.edu/csis/lan­guages/comments.html
48. Vector (Wolfram MathWorld)
    https://mathworld.wolfram­.com/Vector.html
49. n-Tuple (Wolfram MathWorld)
    https://mathworld.wolfram.com/n-Tuple.html
50. n-Vector (Wolfram MathWorld)
    https://mathworld.wolfram.com/n-Vector.html
51. Matrix (Wolfram MathWorld)
    https://mathworld.wolfram­.com/Matrix.html
52. Array (Wolfram MathWorld)
    https://mathworld.wolfram­.com/Array.html
53. ND Arrays (Tensors) in different languages
    https://www.youtube.com/wat­ch?v=WbpbEilgQBc
54. Extending APL to Infinity\
    https://www.jsoftware.com/pa­pers/eem/infinity.htm
55. Vector Library (R7RS-compatible)
    https://srfi.schemers.org/srfi-133/srfi-133.html
56. Vectors (pro Gauche)
    https://practical-scheme.net/gauche/man/gauche-refe/Vectors.html
57. Kawa: Compiling Scheme to Java
    https://www.mit.edu/afs.new/sip­b/project/kawa/doc/kawa-tour.html
58. Kawa in Languages shootout
    http://per.bothner.com/blog/2010/Kawa-in-shootout/
59. Kawa 2.0 Supports Scheme R7RS
    https://developers.slashdot­.org/story/14/12/13/2259225/ka­wa-20-supports-scheme-r7rs/
60. Kawa — fast scripting on the Java platform
    https://lwn.net/Articles/623349/
61. Incanter is a Clojure-based, R-like platform for statistical computing and graphics.
    http://incanter.org/
62. Evolution of incanter (Gource Visualization)
    https://www.youtube.com/wat­ch?v=TVfL5nPELr4
63. Questions tagged [incanter] (na Stack Overflow)
    https://stackoverflow.com/qu­estions/tagged/incanter?sor­t=active
64. Data Sorcery with Clojure
    https://data-sorcery.org/contents/
65. Back to the Future: Lisp as a Base for a Statistical Computing System
    https://rd.springer.com/chap­ter/10.1007/978–3–7908–2084–3_2
66. Incanter Cheat Sheet
    http://incanter.org/docs/incanter-cheat-sheet.pdf
67. Back to the Future: Lisp as a Base for a Statistical Computing System (celá verze článku)
    https://www.researchgate.net/pu­blication/227019917_Back_to_the_Fu­ture_Lisp_as_a_Base_for_a_Sta­tistical_Computing_System
68. BQN: finally, an APL for your flying saucer
    https://mlochbaum.github.io/BQN/
69. Is BQN stable?
    https://mlochbaum.github.i­o/BQN/commentary/stability­.html
70. Specification: BQN system-provided values
    https://mlochbaum.github.i­o/BQN/spec/system.html
71. Tutorial: BQN expressions
    https://mlochbaum.github.i­o/BQN/tutorial/expression­.html
72. BQN primitives
    https://mlochbaum.github.i­o/BQN/doc/primitive.html
73. Function trains
    https://mlochbaum.github.i­o/BQN/doc/train.html
74. BQN community links
    https://mlochbaum.github.i­o/BQN/community/index.html
75. BQN UV
    https://observablehq.com/@lsh/bqn-uv
76. APL Wiki
    https://aplwiki.com/wiki/
77. The Array Cast
    https://www.arraycast.com/e­pisodes/episode-03-what-is-an-array
78. EnthusiastiCon 2019 – An Introduction to APL
    https://www.youtube.com/wat­ch?v=UltnvW83_CQ
79. Dyalog
    https://www.dyalog.com/
80. Try APL!
    https://tryapl.org/
81. Lisp-Stat Information
    http://homepage.cs.uiowa.e­du/~luke/xls/xlsinfo/
82. Sample Plots in Incanter
    https://github.com/incanter/in­canter/wiki/Sample-Plots-in-Incanter#line
83. vectorz-clj
    https://github.com/mikera/vectorz-clj
84. vectorz – Examples
    https://github.com/mikera/vectorz-clj/wiki/Examples
85. Basic Vector and Matrix Operations in Julia: Quick Reference and Examples
    https://queirozf.com/entries/basic-vector-and-matrix-operations-in-julia-quick-reference-and-examples
86. Vectors and matrices in Julia
    https://fncbook.github.io/v1­.0/linsys/demos/matrices-julia.html
87. Array vs Matrix in R Programming
    https://www.geeksforgeeks.org/array-vs-matrix-in-r-programming/
88. Concurrency (computer science)
    https://en.wikipedia.org/wi­ki/Category:Concurrency_%28com­puter_science%29
89. Koprogram
    https://cs.wikipedia.org/wi­ki/Koprogram
90. Coroutine
    https://en.wikipedia.org/wi­ki/Coroutine
91. Coroutines in C
    http://www.chiark.greenen­d.org.uk/~sgtatham/corouti­nes.html
92. S-expression (Wikipedia)
    https://en.wikipedia.org/wiki/S-expression
93. S-Expressions (Rosetta Code)
    http://rosettacode.org/wiki/S-Expressions
94. Introducing Julia/Metaprogramming
    https://en.wikibooks.org/wi­ki/Introducing_Julia/Meta­programming
95. Tutorial for the Common Lisp Loop Macro
    http://www.ai.sri.com/pkarp/loop.html
96. Clojure Macro Tutorial (Part I, Getting the Compiler to Write Your Code For You)
    http://www.learningclojure­.com/2010/09/clojure-macro-tutorial-part-i-getting.html
97. Clojure Macro Tutorial (Part II: The Compiler Strikes Back)
    http://www.learningclojure­.com/2010/09/clojure-macro-tutorial-part-ii-compiler.html
98. Clojure Macro Tutorial (Part III: Syntax Quote)
    http://www.learningclojure­.com/2010/09/clojure-macro-tutorial-part-ii-syntax.html
99. Clojure Macros and Metaprogramming
    http://clojure-doc.org/articles/language/macros.html
100. Fatvat – Exploring functional programming: Clojure Macros
     http://www.fatvat.co.uk/2009/02/clo­jure-macros.html
101. CS 2101 Parallel Computing with Julia
     https://www.coursehero.com/fi­le/11508091/CS-2101-Parallel-Computing-with-Julia/
102. Julia By Example
     https://samuelcolvin.github­.io/JuliaByExample/
103. Array Programming
     https://en.wikipedia.org/wi­ki/Array_programming
104. Discovering Array Languages
     http://archive.vector.org­.uk/art10008110
105. no stinking loops – Kalothi
     http://www.nsl.com/
106. Vector (obsahuje odkazy na články, knihy a blogy o programovacích jazycích APL, J a K)
     http://www.vector.org.uk/
107. APL Interpreters
     http://www.vector.org.uk/?a­rea=interpreters
108. APL_(programming_language
     http://en.wikipedia.org/wi­ki/APL_(programming_langu­age
109. APL FAQ
     http://www.faqs.org/faqs/apl-faq/
110. APL FAQ (nejnovější verze)
     http://home.earthlink.net/~swsir­lin/apl.faq.html
111. A+
     http://www.aplusdev.org/
112. APLX
     http://www.microapl.co.uk/
113. FreeAPL
     http://www.pyr.fi/apl/index.htm
114. Learning J (Roger Stokes)
     http://www.jsoftware.com/hel­p/learning/contents.htm
115. J: a modern, high-level, general-purpose, high-performance programming language
     http://www.jsoftware.com/
116. K, Kdb: an APL derivative for Solaris, Linux, Windows
     http://www.kx.com
117. openAPL (GPL)
     http://sourceforge.net/pro­jects/openapl
118. Parrot APL (GPL)
     http://www.parrotcode.org/
119. Learning J (Roger Stokes)
     http://www.jsoftware.com/hel­p/learning/contents.htm
120. Rosetta Code
     http://rosettacode.org/wiki/Main_Page
121. Why APL
     http://www.acm.org/sigapl/whyapl.htm
122. Introducing Julia/Functions
     https://en.wikibooks.org/wi­ki/Introducing_Julia/Functi­ons
123. Functions (Julia documentation)
     https://docs.julialang.or­g/en/v1/manual/functions/
124. Evaluate binomial coefficients
     http://rosettacode.org/wi­ki/Evaluate_binomial_coef­ficients
125. Ackermann function
     http://rosettacode.org/wi­ki/Ackermann_function
126. Julia (front page)
     http://julialang.org/
127. Julia – dokumentace
     http://docs.julialang.org/
128. Julia – repositář na GitHubu
     https://github.com/JuliaLang/julia
129. Julia (programming language)
     https://en.wikipedia.org/wi­ki/Julia_%28programming_lan­guage%29
130. IJulia
     https://github.com/JuliaLan­g/IJulia.jl
131. Introducing Julia
     https://en.wikibooks.org/wi­ki/Introducing_Julia
132. Julia: the REPL
     https://en.wikibooks.org/wi­ki/Introducing_Julia/The_REPL
133. Month of Julia
     https://github.com/DataWo­okie/MonthOfJulia
134. Learn X in Y minutes (where X=Julia)
     https://learnxinyminutes.com/doc­s/julia/
135. New Julia language seeks to be the C for scientists
     http://www.infoworld.com/ar­ticle/2616709/application-development/new-julia-language-seeks-to-be-the-c-for-scientists.html
136. Julia: A Fast Dynamic Language for Technical Computing
     http://karpinski.org/publi­cations/2012/julia-a-fast-dynamic-language
137. The LLVM Compiler Infrastructure
     http://llvm.org/
138. Julia: benchmarks
     http://julialang.org/benchmarks/
139. Type system
     https://en.wikipedia.org/wi­ki/Type_system
140. Half-precision floating-point format
     https://en.wikipedia.org/wiki/Half-precision_floating-point_format
141. Dartmouth BASIC
     https://en.wikipedia.org/wi­ki/Dartmouth_BASIC
142. BASIC 4th Edition
     http://www.bitsavers.org/pdf/dar­tmouth/BASIC_4th_Edition_Jan68­.pdf
143. VECTRAN
     https://encyclopedia2.the­freedictionary.com/VECTRAN
144. Comparison of programming languages (array)
     https://en.wikipedia.org/wi­ki/Comparison_of_programmin­g_languages_(array)
145. BASIC at 50
     https://www.dartmouth.edu/ba­sicfifty/commands.html
146. BBC Basic – arrays
     http://www.riscos.com/sup­port/developers/bbcbasic/par­t2/arrays.html
147. Datová struktura
     https://cs.wikipedia.org/wi­ki/Datov%C3%A1_struktura
148. SIMD instrukce využívané v moderních mikroprocesorech řady x86
     https://www.root.cz/clanky/simd-instrukce-vyuzivane-v-modernich-mikroprocesorech-rady-x86/
149. SIMD instrukce v moderních mikroprocesorech řady x86 (2.část: SSE)
     https://www.root.cz/clanky/simd-instrukce-v-modernich-mikroprocesorech-rady-x86–2-cast-sse/
150. SIMD instrukce v moderních mikroprocesorech řady x86 (3.část: SSE2)
     https://www.root.cz/clanky/simd-instrukce-v-modernich-mikroprocesorech-rady-x86–3-cast-sse2/
151. Inductive type
     https://en.wikipedia.org/wi­ki/Inductive_type
152. JuliaMono, a font for programming
     https://github.com/cormulli­on/juliamono
153. It’s arrays all the way down
     https://xpqz.github.io/le­arnapl/array.html
154. APL vs BQN vs J vs Q vs NumPy vs Julia vs R
     https://www.youtube.com/wat­ch?v=8ynsN4nJxzU
155. Trainspotting (APL)
     https://xpqz.github.io/le­arnapl/tacit.html
156. Train Spotting in Dyalog APL – Dyalog Webinar with Richard Park
     https://www.youtube.com/wat­ch?v=Enlh5qwwDuY