Datové typy  (perldata)
===========
Skalár: řetězec, integer, float, reference
  -> obvykle obsahuje právě jednu z těchto hodnot a na jiné se
     automaticky konvertuje
  -> existují polymorfní skaláry, které mají více typů najednou

Pole: indexy jsou 0..N, hodnoty skaláry

Hash: indexy jsou řetězce, hodnoty libovolné skaláry
  -> pokud je indexem něco jiného, automaticky se konvertuje
     -> takže $hash{$reference} sice funguje, ale keys %hash
        vrací řetězce, které nelze dereferencovat
     -> pozor na $hash{0.0} vs. $hash{"0.0"}
  -> trik: $hash{$i, $j, $k} emuluje vícerozměrné pole, indexy slepí
     a oddělí hodnotou $; (default: netištitelný znak \034)

Existují magické objekty, které si definují vlastní sémantiku operací
  -> třeba hash, který je ve skutečnosti databáze na disku  (viz perltie)

Reference na skaláry  (perlref)
====================
${$var}			<-- symbolická reference (to není opravdová reference)
my $r = \$var		<-- reference na skalár
my $r = \123		<-- reference na read-only skalár
say ${$r}		<-- dereferencování
say $$r			<-- zkrácený zápis
for (1..10) { my $a; push @x, \$a; }	<-- pokaždé jiná reference

Reference na pole  (perlref)
=================
\@pole			<-- reference na pole
[ 1, 2, 3 ]		<-- vytvoří anonymní pole a vrátí referenci
[ 1, [ 2, 3 ] ]		<-- ... lze vnořovat
\( LIST )		<-- vrací seznam referencí na jednotlivé prvky
@{$r}			<-- dereferencování
${$r}[0], $r->[0]	<-- dereferenování a indexování (oživuje undef)
$r->[0][1]		<-- zkratka za $r->[0]->[1]
$r[0][1]		<-- zkratka za $r[0]->[1]
push $r, ...		<-- automaticky dereferencuje (experimentální!)

Reference na hashe  (perlref)
==================
\%hash			<-- reference na hash
{ a => 1, b => 2 }	<-- vytvoří anonymní hash a vrátí referenci
%{$r}, $r->{$key}	<-- podobně jako u polí
$r[0]{abc}[1]		<-- lze libovolně míchat
sub h {{ @_ }}		<-- nejednoznačné, může to být hash i blok!
sub h {+{ @_ }}		<-- zde je to hash
sub h { return {@_} }	<-- zde také
sub h {{; @_ }}		<-- zde je to blok

Reference na funkce  (perlref)
===================
\&funkce		<-- reference na funkci
$r = sub { print "Boink!\n" };	<-- anonymní funkce, pozor na středník!
&$r(1, 2, 3)		<-- volání
$r->(1, 2, 3)		<-- jiný zápis volání

sub f {			<-- closures (vazby na lokální proměnné)
	my $cnt = 0;
	return sub { return $cnt++; }
};
my $g = f();
say $g->(), $g->()

Různé  (perlref)
=====
$r == $r2 / $r <=> $r2	<-- reference se konvertují na číselné adresy
print $r		<-- "SCALAR(0x123456)"
ref $r			<-- vrátí "SCALAR", "ARRAY", ..., ""
Pozor na cyklické reference, hodí se Scalar::Util::weaken
   ... ale kopie slabé reference je zase silná reference

Tabulky symbolů  (perlref)
===============
*ident			<-- celá položka v tabulce symbolů
*ident{SCALAR}		<-- skalární význam identifikátoru
*f{CODE} = sub { ... }	<-- generování pojmenované funkce za běhu
*{$f}{CODE}		<-- pokud generuji i její jméno
*ident = \$scalar	<-- magic: přepíši jen *ident{SCALAR}
local *IN{IO}		<-- lokalizuje file-handle