Překladače
==========

NQP ---> QAST -+-> MAST ---> MoarVM
          ^    |
Perl6-----/    \-> JAST ---> JVM ...

- překladač i knihovna NQP jsou implementovány v NQP
- Rakudo je implementováno v NQP, knihovna P6 v NQP + P6

## NQP toolchain ##

- parsování gramatikami se sémantickými akcemi, vzniká nejprve
  syntaktický strom, z něj QAST, který se předá back-endu
- více subjazyků: hlavní, regexový, quotovací (%*LANG<Regex> apod.)
- HLL::Compiler => NQP::Compiler / Perl6::Compiler (Rakudo)

Serializace
-----------

- Ukládáme do souboru stav VM ("world"):
   * přeložené bloky kódu
   * zkonstruované objekty
   * kód ke spuštění po deserializaci
- Ukladání stavu se zastaví o objekty, které už byly uloženy dříve,
  ale poznamená si, co všechno je před deserializací potřeba obstarat.
- GLOBAL scope se poskládá z příspěvků jednotlivých světů

NQP
===

- Typy:
    * integer (bigint, native)
    * float
    * string
    * pole, heše
    * třídy, role
- Neexistuje přiřazení, jen binding => nemáme kontejnery
- Nemá líné vyhodnocování
- Zjednodušený multi-dispatch
- Chybí většina builtinů a syntaktického cukru
- Základní operace nqp::*, třeba:
    * Čísla: běžná aritmetika (tu lze psát i jako operátory),
             porovnávání, libm
    * Pole: elems, push, pop, list, atpos, bindpos
    * Heše: elems, existskey, deletekey
    * Různé: bind, call, time_n
    * Řídicí: if, ifnull, for, while
- Zjednodušený objektový systém
    * Minimum syntaxe => na některé věci nutno volat metatřídy
    * Jediný zabudovaný metaobjekt "knowhow", umí jenom metody a atributy
      bez jakéhokoliv odvozodování tříd
    * V knihovně implementovány metaobjekty pro další typy (třeba třídy)
- Takřka plnohodnotný systém gramatik a sémantických akcí

QAST
====

- Všechno jsou potomci QAST::Node, každý si pamatuje:
    * seznam synů
    * heš pojmenovaných anotací
    * nepovinný návratový typ
    * odkaz na pozici ve zdrojáku

CompUnit		Samostatně kompilovaný kus programu
Block			Blok: kus kódu + lexpad; typy: declaration, immediate
Stmts			Posloupnost příkazů, poslední (či určený) vydá výsledek
Stmt			Obálka jednoho příkazu, na konci lze uvolnit temporaries
Op			Libovolná nqp::op
IVal / NVal / SVal	Literál celočíselný / floatový / stringový
BVal			Odkaz na blok
WVal			Odkaz na "world value" (objekt vytvořený při kompilaci)
Var			Deklarace nebo lookup proměnné (či parametru)
Want			Výběr z variant podle kontextu (třeba obecný vs. nativní)
VM			Výběr z variant podle toho, na jakém VM běžíme

6model
======

- sada primitiv pro budování typových a objektových systémů :)
- existuje překladač 6modelu pro Parrot a JVM; MoarVM ho implementuje přímo
- objektový typ definuje:
    * uložení stavu objektu v paměti => reprezentace
        # reprezentace jsou implementovány virtuálním strojem
	# P6int, P6num, P6str (nativní), P6bigint, P6opaque (cokoliv)
	# VMArray, VMHash, Uninstantiable
    * chování (způsob volání metody určené jménem) ... může být určeno objektem,
      třídou, nebo třeba poskládané z více tříd => meta-objekty
        # typicky se jmenují <něco>HOW
	# Perl6::ClassHOW, NQP::NQPClassHOW, NQP::KnowHOW
- objekt se odkazuje na STable (shared table), v ní je:
    * odkaz na definici reprezentace
    * odkaz na meta-objekt
    * odkaz na typový objekt
    * cache volání metod (může být autoritativní)
    * cache typových kontrol
    * mód boolifikace, implementace callable
    * může být označen jako kontejner (pak část nqp::* dekontejnerizuje)
- v okamžiku kompozice objektu se fixuje reprezentace

MoarVM
======

- implementuje objekty pomocí 6modelu
- instrukční sada vychází poměrně přímočaře z nqp::*
    * překladač z QAST generuje MAST, z toho pak posloupnost instrukcí
    * založený na virtuálních registrech, nikoliv na zásobníku
- 2-generační garbage collector s kopírováním objektů
- podpora Unicodových stringů v NFG
- podpora vláken, většina struktur uvnitř je lock-free
- optimalizace
    * eliminace box-unbox
    * specializace
    * unrolling smyček
    * spekulativní optimalizace
- just-in-time kompilace do strojového kódu na x64

Makra
=====

use experimental :macros;

macro checkpoint {
    my $i = ++(state $n);
    quasi { say "CHECKPOINT $i"; }
}

checkpoint;		# 1
for ^5 { checkpoint }	# 2 (5x)

constant LOGGING = True;
macro LOG($message) {
    if LOGGING {
        quasi { say {{{$message}}} };
    } else {
        Nil;
    }
}