Regulární výrazy (rules)

Na začátek povězme, že staré regulární výrazy lze nadále používat. Syntaxe pro to je následující.

if $p ~~ m:Perl5/^\w\d[a-d]$/ {
    say "OK";
}

Avšak regulární výrazy prošly revolučními změnami. V Perlu 5 mají dle Larryho Walla několik zásadních nedostatků. Je určitě zajímavé zamyslet se nad následujícími body.

• too compact and cute
• too much reliance on too few metacharacters
• little support for named captures
• little support for grammars
• poor integration with real language

Perl 5 podporoval tzv. regexes, což jsou regulární výrazy rozšířené oproti jejich formální definici (my v seriálu nejsme úplně korektní a tyto pojmy zaměňujeme). Perl 6 bude obsahovat novou soustavu regulárních výrazů pod názvem rules (pravidla). Pro detailní informace je nejvhodnější nahlénout do specifikace.

V Perlu 6 je syntaxe a možnosti regulárních výrazů hodně odlišná od předchozích verzí. Mění se i filozofie, s jakou je k regulárním výrazům přistupováno. V Perlu 5 byly regulární výrazy od zbytku programu dost oddělené - byl to speciální řetězec, jehož význam se řídil vlastními pravidly a na první pohled bylo jasně vidět, že regulární výraz je něco jiného než zbytek programu. To se nyní změnilo a regulární výrazy jsou do jazyka daleko více zabudované.

Co se nezměnilo

Nejzákladnější vlastnosti se neliší.

• Znak | pro alternativy
• Čísla, písmena, podtržítko a escapované znaky pomocí \ matchují doslovně
• (...) funguje jako zachycení řetězce
• Pro kvantifikátory zde máme znaky ? * + ?? *? +?, již však nemáme kvantifikátor {od, do}

Drobné změny

Téměř vše ostatní se ale změnilo. Podívejme se, co se stalo s několika často používanými konstrukcemi.

• Místo nezachytávacích závorek (?:...) nyní budeme používat [...], které dosud sloužily jako závorky pro množinu znaků.
• Pro vkládání kódu použijeme <?{...}>
• Nově nezáleží na bílých znacích uvnitř regulárního výrazu, tj. je automaticky zapnut modifikátor x
• Mění se syntaxe pro pozitivní/negativní pohled dopředu/dozadu. Pro pozitivní resp. negativní pohled dopředu použijeme <before ...> resp. <!before ...>. Podobně pro pohled dozadu s after.
• Kvantifikátory pro rozsahy mají tvar **{2 .. 7}, **{2 .. 7}?.
• Místo operátorů =~ a !~ máme nově ~~ a !~~.
• ^^ je nová kotva pro začátek řádku, $$ pro konec řádku
• Pojmenované zachytávání se děje následující speciální konstrukcí: /Cislo: $<jmeno_promenne>:=(\d+)/. Potom budeme mít zachycená data v proměnné $jmeno_promenne a nebudeme muset používat $0. Také je vhodné zmínit, že výsledkem zachytávání bude zanořená datová struktura, nikoliv pouze seznam hodnot.
• Tečka nově zastupuje i znak nového řádku

Formální gramatiky, modifikátory

V Perlu 6 lze daleko intuitivněji definovat pravidla pro formální gramatiky. Například, mějme jazyk, který můžeme chápat jako množinu slov L = {aⁿbabⁿ | n > 0} (mimochodem, nejde o regulární jazyk). To lze v Perlu přepsat do pravidla následovně pomocí deklarátoru rule (které se používá k deklaraci pojmenovaného nebo anonymního regulárního výrazu).

rule S {(a+) ba (b+) <{$0.elems == $1.elems}>}

Zde je jiný způsob. Velmi přehledně lze přepisovat gramatiky. Pravidla pro tvorbu slov jsou v našem jazyku následující.

S -> a S b
S -> b a

Totéž tedy bude dělat toto pravidlo.

rule S {a S b | b a}

Dále existují také deklarátory regex, rx a token, které se liší v tom, jaké modifikátory jsou automaticky aktivní. Máme na výber z mnoha modifikátorů. Uvádějí se uvozené dvojtečkou za jméno pravidla (tj. podobně jako atributy u podprogramů) nebo před regulární výraz (je-li anonymní, například m:i:g/hledane_slovo/).

Zde je několik příkladů modifikátorů.

Perl 6 navíc umožňuje definici vlastních modifikátorů. Pro obsáhlejší informace o modifikátorech lze doporučit nahlédnutí do dokumentace.

Klíčové slovo grammar deklaruje jmenný prostor pro pravidla. Názorněji si představme grammar jako analogii package. package obsahuje metody, podobně grammar obsahuje nějaké regulární výrazy.

Uveďme si hodně umělý příklad na validaci emailové adresy, na kterém ale uvidíme, jak se výše uvedené používá. Používá se Backus-Naurova normální forma.

grammar Email::Simple {
    regex email {<uzivatel> @ <server> \. <koncovka>}
    token uzivatel {[\w\.\-]+}
    token server {[\w\.\-]+}
    token koncovka {cz|com|info}
}

Nyní se můžeme vně jmenného prostoru například na regex email odvolávat jako na Email::Simple::email. Jak tedy ověříme správnost emailu?

if $email ~~ /Email::Simple::email/ {
    say "OK";
}

Nové operátory

Podívejme se, jaké nové operátory nám Perl 6 přináší. Již jsme se s některými setkali v minulém dílu a nyní se věnujme dalším. Na úvod je dobré se alespoň letmo podívat na kompletní přehled operátorů, kde uvidíme desítky úplně nových.

Výraz pro vícenásobné porovnávání

Nově lze zřetězit operátory pro porovnávání. Lze tak vytvořit následující podmínku.

if (1 <= 5 < 10){
    say "OK";
}

Nové operátory pro kartézský součin a operace po složkách

Operátor X je tzv. metaoperátor, což je velmi zajímavá věc. Základní použití je následující.

say ((1, 2) X (4, 5)).perl; # tiskne ((1, 3), (1, 4), (2, 3), (2, 4))

Použití však je daleko širší, neboť lze specifikovat, jakým operátorem mají interagovat každé dva prvky. Implicitně je to čárka. Lze ale použít i jiné operátory. Operátor uvedeme za X.

say ((1, 2) X~  (3, 4)).perl   # tiskne ("13", "14", "23", "24")
say ((1, 2) X*  (3, 4)).perl   # tiskne (3, 4, 6, 8)
say ((1, 2) X== (3, 4)).perl   # tiskne (Bool::False, Bool::False, Bool::False, Bool::False)

Stojí za zamyšlení, jak bychom libovolný z uvedených příkladů napsali v Perlu 5.

Pro operace po složkách lze stejným způsobem použít operátor Z. Vždy spolu interagují ntý prvek v pravém seznamu a ntý prvek v levém seznamu. Podívejme se, jak efektně můžeme v Perlu 6 sčítat vektory nebo tvořit hashe.

say ((1, 2) Z+ (3, 4)).perl                     # tiskne (4, 6)
%hash = @zavodnici Z=> @jejich_osobni_rekordy   # vytvoří hash

Definice vlastních operátorů

V Perlu 6 máme následující typy operátorů.

Jak bychom například vytvořili a použili operátor pro zaokrouhlování (za předpokladu, že máme funkci round)?

multi sub prefix:<°> (Rat $arg) {
    return round($arg);
}
say °3.14;

Měli bychom ale také specifikovat prioritu právě definovaného operátoru a asociaci. To uděláme v případě priority pomocí slov equiv, tighter, looser vzhledem k již existujícím operátorům a pomocí assoc s parametrem left, right nebo none. Například takto.

multi sub infix:<°> is equiv(&infix:<*>){ ...  }
multi sub infix:<°> is tighter(&infix:<*>){ ... }
multi sub infix:<°> is looser(&infix:<*>){ ... }
multi sub infix:<°> is assoc("left"){ ... }

Pomocí multi můžeme také přetěžovat již existující operátory.

Generování posloupností čísel

Perl 6 zavádí nový třítečkový operátor pro rozsahy s líným vyhodnocováním. Díky němu můžeme elegantně generovat různé aritmetické a geometrické posloupnosti.

1, 2, 4 ... *     # generuje posloupnost mocnin dvou
1, 3, 9 ... *     # generuje posloupnost mocnin tří
0, 2 ... *        # generuje posloupnost sudých čísel
1, 3 ... *        # generuje posloupnost lichých čísel
5, 4 ... *        # generuje posloupnost čísel od 5 do minus nekonečna
1.1, 1.2 ... 5.3  # generuje posloupnost čísel od 1,1 do 5,3 s krokem 0.1

Co když chceme omezenou posloupnost, ale nevíme z hlavy poslední člen? Co například mocniny dvou do 10000?

1, 2, 4 ... 10000

To bohužel fungovat nebude, protože vygenerovaný člen je vždy porovnáván s posledním na rovnost. Příklad tedy vygeneruje nekonečnou posloupnost. Avšak existuje trik, který ji ukončit dokáže, i když poslední člen nevíme.

1, 2, 4 ... * >= 10000

Místo >= lze použít i jiný operátor. Tato konstrukce je zkratkou za uzávěr -> $a {$a >= 10000}. Totéž lze nezkráceně napsat takto.

1, 2, 4 ... -> $a {$a >= 10000}

Když chceme generovat posloupnost, která není ani aritmetická ani geometrická, musíme ji definovat jako lambda funkci. Vzpomeňme si, jak jsme psali podprogram na výpočet Fibonacciho posloupnosti. Takto ji přiřadíme do pole v Perlu 6.

my @fibonacci := 0, 1, -> $a, $b {$a + $b} ... *;

S trochou magie lze totéž přepsat takto.

my @fibonacci := 0, 1, * + * ...^ *

Výsledek po operaci ... lze samozřejmě přiřadit do pole.

@mocniny_dvou = 1, 2, 4 ... *;

Prvních 6 elementů vytiskneme takto.

say @mocniny_dvou[^6];

Další změny v operátorech

Podívejme se v bodech na několik zajímavých změn.

• Je zaveden nový feed operátor <==, který dělá současné používání příkazů typu map, grep atd. podstatně čitelnější.
• Operátor := se používá k ztotožnění dvou proměnných.
• Operátor =:= rozhodne, zda dvě proměnné ukazují na totéž.
• Operátor ~ se používá pro zřetězení.
• Podmínkový operátor má nyní novou syntaxi: podmínka ?? v_případě_true !! v_případě_false.
• Operátor pro identitu: ===, eqv.
• Nové relační operátory pro negaci: !===, !=:=, !==, !eq, !eqv.
• Zaujmout by mohly též operátory pro minimum a maximum, které lze použít následovně: 5 min 7 max 2. Samozřejmě existují i odpovídající max= a min=.
• Máme dva replikační operátory: x je pro skaláry a xx pro seznamy.