Metody polí
===========
.elems		<-- počet prvků
.end		<-- poslední index
.pop / .push / .shift / .unshift
.prepend / .append	<-- přidává více prvků
.map		<-- též jako funkce, hodí se vracet Slip
.grep condition, @list	<-- smart-matching
.first condition, @list	<-- první prvek vyhovující podmínce
.pick($n)	<-- náhodný výběr bez opakování
.roll($n)	<-- náhodný výběr s opakováním
.rotor($k, :partial)	<-- rozdělí na $k-tice
	$k => $l	<-- mezi $k-ticemi přeskoč $l prvků (co když $l<0?)
	$k, $l, $m	<-- $k-tice, $l-tice, $m-tice, $k-tice, ...

Hashes
======
zobrazení ze stringových klíčů do hodnot ve skalárních kontejnerech
my %h = 'red' => 1, 'green' => 2, 'blue' => 3	<-- lze i "blue => 3"
%h{'violet'} = 4
%h<infrared> = 0
%h<black white>		<-- řez hešem (lze do něj i přiřazovat)
%h<black>:exists	<-- testuje existenci
%h<black>:delete	<-- přečte hodnotu a smaže ji
%h<black white>:p	<-- vrátí seznam párů klíč => hodnota
{ black => 0, white => 1 }
{ black => $_ }		<-- POZOR: toto není heš, ale lambda
%( black => $_ )	<-- můžeme obejít alternativní syntaxí
%h = <black 0 white 1>;
my Int %h;		<-- omezíme typ hodnot
my %h is default('-');	<-- hodnota pro nepřítomné klíče

Metody hešů  (podobné polím)
===========
.elems			<-- počet párů
.push($k => $v, ...)	<-- pokud už hodnota existovala, vytvoří seznam
	# pozor na syntaxi:
	# %h.push(none => -1) je pojmenovaný argument metody push
	# %h.push('none' => -1) udělá to, co chceme
.keys			<-- fungují i pro pole :)
.values
.kv			<-- střídavě klíče a hodnoty
.pairs
{ a => [1,2] }.antipairs  <-- { [1,2] => 'a' }
{ a => [1,2] }.invert	<-- { 1 => 'a', 2 => 'a' }

Další hešovité struktury
========================
my %h{Date};		<-- jiné než stringové klíče (lze i {Any}),
			    ale pozor, nic se implicitně nekonvertuje
Set, set<a b c>		<-- immutable množina, umí (&), (|), (<) apod.
SetHash			<-- mutable verze Setu: lze %s{$key} = True
Bag / BagHash		<-- multimnožiny s přirozenými vahami
Mix / MixHash		<-- multimnožiny s reálnými vahami

Given/when
==========
given $x {		<-- topicalizer
    when 42 { ... }	<-- na konci bloku vyskočí z given
    when 84 {
	proceed;	<-- pokračujeme dalším when
	succeed;	<-- vyskočíme z given, lze předat výsledek
    }
    default { ... }
}
# given/when lze použít i samostatně

Smart match
===========
Operátor $a ~~ $b: matchuje hodnotu $a vůči patternu $b
When dělá implicitně $_ ~~ $arg
~~ Type			<-- hodnota je daného typu
~~ string		<-- stringová rovnost
~~ číslo		<-- numerická rovnost
~~ regex		<-- vyhovuje regexu
~~ funkce		<-- zavolá a uspěje, pokud vyjde true
~~ bool			<-- uspěje, pokud je bool true (ignoruje hodnotu)
~~ 1 | 2		<-- varianta (junction, viz později)

Funkce
======
sub f {			<-- implicitně my
	return 42;	<-- vrací výsledek (jinak poslední vyhodnocený výraz či Any)
	return-rw $a;	<-- vrací kontejner (výsledek je read-write)
}
sub f($x, $y) { ... }	<-- funkce se signaturou (viz dále)
sub { ... }		<-- anonymní funkce
			    jako implicitní argumenty může sloužit $_, $^cosi
{ ... }			<-- blok, liší se od anonymní sub tím, že return propadává ven
-> $x, $y { ... }	<-- blok se signaturou

Signatury
=========
$x			<-- proměnná, na kterou se read-only binduje argument
$x is rw		<-- read-write binding (<-> u bloků)
$x is copy		<-- kopie hodnoty
Int $x			<-- omezení na typ
$x where { $x > 0) }	<-- omezení obecnou podmínkou
$ where 42		<-- omezení hodnotou (ve skutečnosti where smart-matchuje)
42			<-- totéž
Int(Cool) $x		<-- akceptuje Cool, interně konvertuje na Int
Int() $x		<-- akceptuje cokoliv, interně Int
$name?			<-- nepovinný parametr
$name = "Nobody"	<-- nepovinný parametr s defaultem
			    (default je výraz, může se odkazovat na předchozí parametry)
:$switch		<-- pojmenovaný parametr (nepovinný)
:$switch!		<-- může být zpovinněn
*@a			<-- zbývající poziční argumenty uložit do pole
**@a			<-- *@a zplošťuje seznamy, **@a nikoliv
*%h			<-- zbývající pojmenované do heše

Captures
========
objekt obsahující hodnoty pozičních i pojmenovaných argumentů
f(|$c)			<-- doplnit argumenty z dané capture (slip)
sub f($x, |c)		<-- nevyužité argumenty uložit do capture (pozor, nemá sigil)