\usepackage[latin1]{inputenc}
\usepackage[italian]{babel}
\usepackage[T1]{fontenc}
\usepackage{times}
\usepackage{colortbl}
\usepackage{listings}
\usepackage{tikz}

\lstset{extendedchars,numbers=left,numberstyle=\tiny ,numbersep=5pt,language=Perl,printpod=true,showspaces=false,frame=single,framerule=0pt,backgroundcolor=\color{black!20},basicstyle=\small\ttfamily}

\mode<presentation>
{
\usetheme[hideothersubsections]{Goettingen}
\usecolortheme{beaver}
\usecolortheme{rose}
}
\mode<article>{\usepackage{fullpage}}
\mode<handout>{\setbeamercolor{background canvas}{bg=black!5}}

%% \AtBeginSection[]{
%%   \begin{frame}<beamer>{Argomenti}
%%   \small
%%     \tableofcontents[sectionstyle=show/shaded,subsectionstyle=show/hide/hide]
%%   \end{frame}
%% }

%% \AtBeginSubsection[]{
%%   \begin{frame}<beamer>{Argomenti}
%%     \tableofcontents[sectionstyle=show/hide,subsectionstyle=show/shaded/hide]
%%   \end{frame}
%% }

\newcommand{\Perl}{\textsf{Perl}}
\newcommand{\perl}{\texttt{perl}}

% 'sto coso non va... ed è pure copiato dalla documentazione di beamer!
%% \newenvironment{itemframe}
%% {\begin{frame}\frametitle{gino}\startitemframe}
%% {\stopitemframe\end{frame}}
%
%% \newcommand\startitemframe{\begin{itemize}}
%% \newcommand\stopitemframe{\end{itemize}}

\title{\Perl\ --- corso introduttivo}
\author[perl.it]{perl.it \url{http://www.perl.it/}}
\date[IPW2008]{Italian Perl Workshop 2008}

\begin{document}

\begin{frame}
\titlepage
\end{frame}

% shamelessly lifted from Llama3

\section{Introduzione}

\subsection{Informazioni generali}

\begin{frame}\frametitle{Cosa imparerete}
\begin{itemize}
\item a scrivere ed eseguire programmi Perl
\item a leggere molti semplici programmi altrui
\item a trovare ulteriori informazioni
\end{itemize}
\end{frame}

\begin{frame}\frametitle{Cosa dovete già sapere}
\begin{itemize}
\item usare un editor di testi
\item usare la linea di comando
\item programmare in qualche linguaggio \uncover<2->{(anche se comincia per P)}
\end{itemize}
\end{frame}

\subsection{Cos'è Perl?} % ma perché non va con \textit???

\begin{frame}\frametitle{Il nome}
\begin{itemize}[<+->]
\item \Perl\ è il nome del linguaggio
\item \perl\ è il nome del programma
\item PERL è un errore
\end{itemize}
\end{frame}

\begin{frame}\frametitle{Il nome}
\begin{itemize}[<+->]
\item \emph{non} è una sigla
\item è un nome
\item se proprio volete...
 \begin{itemize}[<+->]
 \item Practical Extraction and Report Language
 \item Pathologically Eclectic Rubbish Lister
 \item Polymorphic Existential Recursive Lambdas
 \end{itemize}
\end{itemize}
\end{frame}

\begin{frame}\frametitle{Interprete o compilatore?}
\addtocounter{beamerpauses}{1}
\begin{description}
\item[Interprete] legge un'istruzione alla volta e la esegue
 \begin{itemize}[<+->]
 \item scova gli errori solo quando ci sbatte
 \item non fa ottimizzazioni serie
 \end{itemize}
\item[Compilatore] trasforma il programma da un linguaggio a un altro
 \begin{itemize}[<+->]
 \item può scovare molti errori staticamente
 \item può ottimizzare il codice
 \item \emph{non è mai sufficiente}
 \end{itemize}
\end{description}
\end{frame}

\begin{frame}\frametitle{Interpreti --- esempi}
\begin{itemize}[<+->]
\item la CPU è un interprete
\item \texttt{bash} è un interprete
\item la JVM è un interprete
\item \perl\ è un interprete
\end{itemize}
\end{frame}

\begin{frame}\frametitle{Compilatori --- esempi}
\begin{itemize}[<+->]
\item \texttt{GCC} è un compilatore
\item \texttt{javac} è un compilatore
\item \perl\ è un compilatore
\end{itemize}
\end{frame}

\begin{frame}\frametitle{Interprete \textit{e} compilatore}
\perl\ esamina l'intero programma, e se non ci sono errori lo
\emph{compila} in una struttura dati in RAM, la quale viene poi
\emph{interpretata}
\end{frame}

\begin{frame}\frametitle{La filosofia}
\begin{itemize}[<+->]
\item simile a un linguaggio naturale
\item TMTOWTDI
\item making easy things easy, and hard things possible
\item \emph{manipulexity} vs. \emph{whipuptitude}
\end{itemize}
\end{frame}

\subsection{Dove trovare \perl}

\begin{frame}\frametitle{Forse non serve}
\begin{itemize}
\item praticamente tutti i sistemi *NIX lo includono
\item pure il MacOS X
\end{itemize}
\end{frame}

\begin{frame}\frametitle{Ma io uso Windows!}
\begin{overprint}
\onslide<1|handout:0>{Mi dispiace per te}
\onslide<2|handout:1>{\begin{itemize}
\item \url{http://win32.perl.org/}
\item \href{http://www.activestate.com/Products/activeperl/index.mhtml}{ActivePerl}, di ActiveState
\item \href{http://win32.perl.org/wiki/index.php?title=Strawberry_Perl}{Starwberry Perl}, se volete qualcosa di più ``normale''
\end{itemize}}
\end{overprint}
\end{frame}

\subsection{Scrivere ed eseguire programmi}

\begin{frame}\frametitle{File di testo}
\uncover<+->{Come la maggior parte dei linguaggi di programmazione,
Perl legge i programmi da semplici file di testo.}

\uncover<+->{Per il momento supponiamo di usare soltanto i caratteri
  dell'insieme ASCII (niente accentate)}

\uncover<+->{È più semplice se usate i fine-linea normali per la
  vostra piattaforma}
\end{frame}

\begin{frame}\frametitle{Convenzioni}
\begin{itemize}[<+->]
\item per i programmi potete usare i nomi che volete
\item certe volte si usa \texttt{.pl} come estensione
\item \texttt{\#!/usr/bin/perl} o \texttt{\#!/usr/bin/env perl}
\item i file che definiscono i moduli devono avere nomi particolari
\end{itemize}
\end{frame}

\begin{frame}[fragile]\frametitle{Esempio minimo}
\begin{lstlisting}
#!/usr/bin/env perl
use strict;
use warnings;

# qui il vostro programma
\end{lstlisting}
\end{frame}

\begin{frame}\frametitle{Esecuzione}
\begin{itemize}[<+->]
\item \texttt{perl nomefile}
\item *NIX: \texttt{chmod +x nomefile; ./nomefile}
\item Windows: trucchi con i file \texttt{.BAT}
\end{itemize}
\end{frame}

\section{Scalari}

\begin{frame}\frametitle{Cos'è uno scalare?}
\begin{itemize}
\item un singolo valore
\item \Perl\ distingue tra {\em singolare} e {\em plurale}
\item numeri e stringhe sono scalari
\end{itemize}
\end{frame}

\subsection{Numeri}

\begin{frame}\frametitle{Semantica dei numeri}
\begin{itemize}
\item i numeri sono trattati in intero o in virgola mobile, in modo trasparente
\item non è un problema vostro
\item<2-> a meno che non dobbiate preoccuparvi della precisione, ma per ora lasciate perdere
\end{itemize}
\end{frame}

\begin{frame}[fragile]\frametitle{Sintassi dei numeri}
\begin{itemize}
\item \lstinline!0!, \lstinline!-1!, \lstinline!1234645564!, \lstinline!1_234_645_564!
\item \lstinline!1.25!, \lstinline!-0.007!, \lstinline!1e12!, \lstinline!-3.5e-7!
\item \lstinline!0240!, \lstinline!0xA0!, \lstinline!0b10100000!
\end{itemize}
\end{frame}

\begin{frame}[fragile]\frametitle{Operazioni sui numeri}
\begin{itemize}
\item \lstinline!2+3!
\item \lstinline!5-7.5!
\item \lstinline!4*12e3!
\item \lstinline!7/3!
\item \lstinline!5%2!
\item \lstinline!3**7!
\end{itemize}
\end{frame}

\begin{frame}[fragile]\frametitle{Confronto tra numeri}
\begin{itemize}
\item \lstinline!2 < 3!
\item \lstinline!7.5 > 5!
\item \lstinline!4 != 12e3!
\item \lstinline!3 <= 7!
\item \lstinline!5 >= 2!
\item \lstinline!3 == 3!
\end{itemize}
\end{frame}

\subsection{Stringhe}

\begin{frame}[fragile]\frametitle{Sintassi delle stringhe (1)}

Stringhe racchiuse tra virgolette singole:

\begin{itemize}
\item \lstinline!'gino'!
\item \lstinline!''!
\item \lstinline!'con l\'apostrofo'!
\item \lstinline!'su!\\
\lstinline!tre!\\
\lstinline!righe'!
\item \lstinline!'con \\ backslash'!
\item \lstinline!'backslash, poi n: \n'!
\end{itemize}
\end{frame}

\begin{frame}[fragile]\frametitle{Sintassi delle stringhe (2)}

Stringhe racchiuse tra virgolette doppie:

\begin{itemize}
\item \lstinline!"gino"!
\item \lstinline!"con \"virgolette\"..."!
\item \lstinline!"con \"a capo\" alla fine\n"!
\item \lstinline!"con\ttabulazioni"!
\item \lstinline!"multiple!\\
\lstinline!righe"!
\end{itemize}
\end{frame}

\begin{frame}[fragile]\frametitle{Operazioni sulle stringhe}
\begin{itemize}
\item \lstinline!'gino' . 'pino'!
\item \lstinline!'nano' x 7!
\end{itemize}
\end{frame}

\begin{frame}[fragile]\frametitle{Confronto tra stringhe}
\begin{itemize}
\item \lstinline!'gino' lt 'pino'!
\item \lstinline!'nano' gt 'mano'!
\item \lstinline!'str1' ne 'str2'!
\item \lstinline!'abcd' le 'wxyz'!
\item \lstinline!'piri' ge 'piri'!
\item \lstinline!'buh' eq 'buh'!
\end{itemize}
\end{frame}

\begin{frame}[fragile]\frametitle{Conversioni implicite}

\Perl\ converte tra numeri e stringhe a seconda di come vengono usati:

\begin{itemize}
\item \lstinline!'5'+3! \visible<2->{$\rightarrow$ \lstinline!8!}
\item \lstinline!4 x 5! \visible<2->{$\rightarrow$ \lstinline!'44444'!}
\end{itemize}
\end{frame}

\begin{frame}[fragile]\frametitle{Conversioni e avvertimenti}
\begin{itemize}
\item mettete {\em sempre} \lstinline!use warnings;! all'inizio dei vostri programmi
\item così, se scrivere \lstinline!'12gino'+3!, otterrete un messaggio di avvertimento:

\texttt{Argument "12gino" isn't numeric in addition (+)}
\end{itemize}

\visible<2->{Otterrete anche molti altri avvertimenti utili. Usate {\em sempre} \lstinline!use strict;use warnings;!}

\end{frame}

\subsection{Variabili scalari}

\begin{frame}[fragile]\frametitle{Nomi di variabile}
\begin{itemize}
\item i nomi di variabile scalare cominciano con \lstinline!$! %$
\item \lstinline!$gino! %$
\item \lstinline!$nome_1! %$
\item \lstinline!$ultima_riga_letta! %$
\end{itemize}

\visible<2->{Cercate di dare nomi sensati alle variabili. \lstinline!$a! {\em non} è un nome sensato. \lstinline!$prezzo! è meglio.}

\end{frame}

\begin{frame}[fragile]\frametitle{Assegnamento}
\begin{itemize}
\item \lstinline!$prezzo_finale = $prezzo * (1+$iva/100)!
\item \lstinline!$nome = 'gino'!
\item \lstinline!$totale += $prezzo_finale!
\item \lstinline!$nome .= ' ' . $cognome!
\end{itemize}
\end{frame}

\begin{frame}[fragile]\frametitle{Dichiarazioni}
\begin{lstlisting}
use strict;
use warnings;

my $a;my ($b,$c);
\end{lstlisting}
\end{frame}
%$

\subsection{Interpolazione}

\begin{frame}[fragile]\frametitle{Interpolazione}
Stringhe tra virgolette doppie {\em interpolano} le variabili:

\begin{itemize}
\item \lstinline!$quanti=12;$msg="Totale: $quanti pezzi"! \visible<2->{$\rightarrow$ \lstinline!Totale: 12 pezzi!}
\item \lstinline!$msg="Totale: \$quanti pezzi"! \visible<2->{$\rightarrow$ \lstinline!Totale: $quanti pezzi!}
\item \lstinline!$misura=7.5;$etichetta="${misura}cm"! \visible<2->{$\rightarrow$ \lstinline!7.5cm!}
\end{itemize}

Usate le graffe intorno al nome per evitare che i caratteri che seguono vengano interpretati come parte del nome.
\end{frame}

\subsection{Input/Output} % print, <>, chomp

\begin{frame}[fragile]\frametitle{Scrivere}
\begin{lstlisting}
print "Buh!\n";
my $a='qualcosa';print $a,"\n";
print "a","b","c";
\end{lstlisting}

\visible<2->{%
\lstinline/Buh!/\\
\lstinline!qualcosa!\\
\lstinline!abc!}
\end{frame}

\begin{frame}[fragile]\frametitle{Leggere}
\begin{lstlisting}
my $riga=<>; # legge una riga
\end{lstlisting}

\visible<2->{Il valore letto {\em include} il carattere di ``a capo''}
\end{frame}

\begin{frame}[fragile]\frametitle{\texttt{chomp}}
\begin{lstlisting}
my $riga=<>; # legge una riga, con \n alla fine
chomp($riga);
\end{lstlisting}

Adesso \lstinline!$riga! non contiene più il carattere di ``a capo''
\end{frame}

\subsection{\texttt{if} e \texttt{while}} % else, elsif

\begin{frame}[fragile]\frametitle{Esecuzione condizionale}
\begin{overprint}
\onslide<1|handout:0>
\begin{lstlisting}
if ($totale > $SOGLIA_SPEDIZIONE_GRATIS) {
   print "Spedizione: gratis\n"
}
\end{lstlisting}
\onslide<2|handout:0>
\begin{lstlisting}
if ($totale > $SOGLIA_SPEDIZIONE_GRATIS) {
   print "Spedizione: gratis\n"
}
else {
   print "Spedizione: costa\n";
}
\end{lstlisting}
\onslide<3|handout:1>
\begin{lstlisting}
if ($totale > $SOGLIA_SPEDIZIONE_GRATIS) {
   print "Spedizione: gratis\n"
}
elsif ($totale < $SOGLIA_MINIMA_ORDINE) {
   print "Compra di più!";
}
else {
   print "Spedizione: costa\n";
}
\end{lstlisting}
\end{overprint}
\end{frame}

\begin{frame}[fragile]\frametitle{Cicli condizionali}
\begin{lstlisting}
my $quanti=0;
while ($quanti < 10) {
  $quanti++;
  print "Siamo a $quanti\n";
}
\end{lstlisting}
\end{frame}

\subsection{Valori particolari} % undef, true/false, defined

\begin{frame}[fragile]\frametitle{\texttt{undef}}
\begin{itemize}
\item una variabile cui non è mai stato assegnato nulla ha valore \lstinline!undef!
\item \lstinline!undef! ha valore numerico \lstinline!0! e valore stringa \lstinline!''! (stringa vuota)
\item usare \lstinline!undef! in un'espressione genera un warning
\end{itemize}
\end{frame}

\begin{frame}[fragile]\frametitle{\texttt{defined}}
\begin{lstlisting}
my $a;
# fai qualcosa...

if (defined $a) { print "\$a non è definita\n" }
else { print "\$a ha valore «$a»\n" }
\end{lstlisting}
\end{frame}
%$

\begin{frame}[fragile]\frametitle{Vero e falso}
\begin{itemize}
\item i seguenti valori sono considerati {\em falsi}:
 \begin{itemize}
 \item \lstinline!0! (il numero zero)
 \item \lstinline!''! (la stringa vuota)
 \item \lstinline!'0'! (la stringa che contiene il singlo carattere ``cifra zero'')
 \item \lstinline!undef!
 \end{itemize}
\item tutti gli altri valori sono {\em veri}
\end{itemize}
\end{frame}

\section{Liste e Array}

\begin{frame}\frametitle{Cos'è un array?}
\begin{itemize}
\item una sequenza di valori {\em scalari}, indicati per posizione
\item \Perl\ distingue tra {\em singolare} e {\em plurale}
\item liste e array sono i plurali
\end{itemize}
\end{frame}

\subsection{Indici}

\begin{frame}[fragile]\frametitle{Indici normali}
Gli indici in un array cominciano da 0:

\begin{lstlisting}
$persone[0]="Cino";
$persone[1]="Dino";
$persone[2]="Gino";
$persone[3]="Lino";
\end{lstlisting}
\end{frame}

\begin{frame}[fragile]\frametitle{Uso}
Potete usare un ``accesso ad elemento di array'' ovunque usereste uno scalare.

\begin{lstlisting}
print $persone[0],"\n";
$totali[3]*=1.2;
\end{lstlisting}

Se usate un indice cui non avete mai assegnato nulla, il suo valore è \lstinline!undef!

\visible<2->{\textbf{Nota:} gli array si ``allungano'' implicitamente}
\end{frame}

\begin{frame}[fragile]\frametitle{Espressioni come indici}
L'indice può essere una qualsiasi espressione (purché abbia un valore
numerico).

\begin{lstlisting}
print $persone[$indice];
$totali[$numero_ordine 
        + $mese * $ordini_mese]
  = $totale_ordine;
\end{lstlisting}
\end{frame}
%$

\begin{frame}[fragile]\frametitle{Indici negativi}
Se usate un numero negativo come indice, accedete ``dal fondo'':

\begin{lstlisting}
$persone[0]="Cino";$persone[1]="Dino";
$persone[2]="Gino";$persone[3]="Lino";

print $persone[-1]; # stampa Lino
\end{lstlisting}

Gli array non si allungano ``all'indietro'': \lstinline!$persone[-10]!
genera un errore (ammesso che non ci siano 10 elementi)
\end{frame}

\begin{frame}[fragile]\frametitle{Ultimo indice}
\lstinline!$#persone! è l'ultimo indice valido per le \texttt{persone}:

\begin{lstlisting}
$persone[0]="Cino";$persone[1]="Dino";
$persone[2]="Gino";$persone[3]="Lino";

print $persone[-1]; # stampa Lino
print $persone[$#persone]; # stampa Lino
\end{lstlisting}
\end{frame}

\subsection{Valori}

\begin{frame}[fragile]\frametitle{Liste}
\begin{itemize}
\item \lstinline!(1, 2, 3)!
\item \lstinline!(1, 2, 3, )!
\item \lstinline!('a', 'b', 'c')!
\item \lstinline!(1, 'a')!
\item \lstinline!()!
\item \lstinline!(1..100)!
\end{itemize}
\end{frame}

\begin{frame}[fragile]\frametitle{\texttt{qw}}
\lstinline!qw! crea liste, da stringhe:
\ \\

\begin{overprint}
\onslide<1|handout:0>
\lstinline!qw(1 2 3)!\\
\lstinline!qw(a b c)!
\onslide<2|handout:0>
\lstinline!qw{1 2 3}!\\
\lstinline!qw{a b c}!
\onslide<3|handout:0>
\lstinline!qw/1 2 3/!\\
\lstinline!qw"a b c"!
\onslide<4|handout:1>
\lstinline!qw(1 2 3)!\\
\lstinline!qw{a b c}!\\
\lstinline!qw/1 2 3/!\\
\lstinline!qw"a b c"!

\end{overprint}
\ \\

\visible<4->{Potete usare i delimitatori che volete. \lstinline!qw! {\em non interpola}, nemmeno se usate le virgolette doppie come delimitatore.}
\end{frame}

\subsection{Assegnamento}

\begin{frame}[fragile]\frametitle{Assegnamento tra liste}
\begin{itemize}
\item \lstinline!my ($nome,$cognome) =!
\lstinline!    ('Gianni','Ceccarelli');!
\item \lstinline!($uno,$due)=($due,$uno)!
\item \lstinline!($p[0],$p[1])=qw(a b)!
\item \lstinline!my ($a,$b,$c)=(1,2)! \visible<2->{nota: \lstinline!$c! vale \lstinline!undef!}
\item \lstinline!my ($a,$b)=(1..10)! \visible<2->{8 valori ignorati}
\end{itemize}
\end{frame}

\begin{frame}[fragile]\frametitle{Variabili array}
\begin{lstlisting}
my @a=(1..10);
print $a[3],"\n";
\end{lstlisting}

\visible<2->{
\lstinline!4!
}

\visible<3->{Sì, \lstinline!@a! è il nome dell'intero array, ma l'accesso a elemento comincia con \lstinline!$!. Potete usare una variable array in ogni posto dove usereste una lista.}

\visible<4->{Una variabile array cui non è mai stato assegnato nulla ha valore \lstinline!()! (lista vuota).}
\end{frame}

\begin{frame}[fragile]\frametitle{Assegnamento, di nuovo}
\begin{lstlisting}
my @a=(1..10);
my @b=(20..29);
my @c=(100,99,@a,50,@b);
\end{lstlisting}

\visible<2->{È equivalente a \lstinline!@c=(100,99,1..10,50,20..29)!: gli array vengono appiattiti.}
\end{frame}

\subsection{Funzioni}

\begin{frame}[fragile]\frametitle{\texttt{pop} e \texttt{push}}
\begin{lstlisting}
my @a=1..5;    # 1 2 3 4 5
my $ultimo
  = pop @a;    # 1 2 3 4
push @a,11;    # 1 2 3 4 11
pop @a;        # 1 2 3 4
push @a,
  12,13,14;    # 1 2 3 4 12 13 14
\end{lstlisting}

\lstinline!pop! e \lstinline!push! agiscono sulla {\em coda} dell'array.
\end{frame}
%$

\begin{frame}[fragile]\frametitle{\texttt{shift} e \texttt{unshift}}
\begin{lstlisting}
my @a=1..5;    # 1 2 3 4 5
my $primo
  = shift @a;  # 2 3 4 5
unshift @a,11; # 11 2 3 4 5
shift @a;      # 2 3 4 5
unshift @a,
  12,13,14;    # 12 13 14 2 3 4 5
\end{lstlisting}

\lstinline!shift! e \lstinline!unshift! agiscono sulla {\em testa} dell'array.
\end{frame}
%$

\subsection{Interpolazione}

\begin{frame}[fragile]\frametitle{Interpolazione}
Stringhe tra virgolette doppie {\em interpolano} le variabili, anche array:

\begin{itemize}
\item \lstinline!my @a=(1..3);$msg="Numeri: @a"! \visible<2->{$\rightarrow$ \lstinline!Numeri: 1 2 3!}
\item \lstinline!$email="dakkar@thenautilus.net"! \visible<2->{errore!}
\item \lstinline!$email="dakkar\@thenautilus.net"! \visible<2->{ok}
\item \lstinline!$email='dakkar@thenautilus.net'! \visible<2->{ok}
\end{itemize}
\end{frame}

\begin{frame}[fragile]\frametitle{Interpolazione di espressioni}
Si possono interpolare anche gli accessi ad elemento:

\begin{itemize}
\item \lstinline!my @a=(1..3);$msg="Numero: $a[1]"! \visible<2->{$\rightarrow$ \lstinline!Numero: 2!}
\item \lstinline!my $a=5;$msg="[boh]$a[1]"! \visible<2->{errore!}
\item \lstinline!my $a=5;$msg="[boh]${a}[1]"! \visible<2->{ok}
\end{itemize}
\end{frame}

\subsection{\texttt{foreach}}

\begin{frame}[fragile]\frametitle{Cicli su liste}
\begin{lstlisting}
foreach my $fratello (qw(Cino Dino Gino Lino)) {
  print "Un fratello si chiama $fratello\n";
}
\end{lstlisting}
\end{frame}

\begin{frame}[fragile]\frametitle{Assegnamenti nel ciclo}
\begin{lstlisting}
my @fratelli=qw(Cino Dino Gino Lino);
foreach my $fratello (@fratelli) {
  $fratello="<$fratello>";
}
\end{lstlisting}

Questo {\em cambia il valore} degli elementi dell'array \lstinline!@fratelli!.
\end{frame}
%$

\begin{frame}[fragile]\frametitle{Assegnamenti nel ciclo}
\begin{lstlisting}
foreach my $fratello (qw(Cino Dino Gino Lino)) {
  $fratello="<$fratello>";
}
\end{lstlisting}

Questo {\em è un errore}.
\end{frame}
%$

\subsection{Il contesto}

\begin{frame}\frametitle{Contesto scalare e lista}
\begin{itemize}
\item ciascuna espressione in un programm \Perl\ viene valutata in un certo {\em contesto}
\item il contesto può essere {\em scalare} o {\em lista}
\item molte funzioni restituiscono risultati diversi a seconda del contesto
\end{itemize}
\end{frame}

\begin{frame}[fragile]\frametitle{Contesto scalare: esempi}
\begin{lstlisting}[escapeinside=«»]
$nome = «{\em \sffamily qualcosa}»;
$totali[3] = «{\em \sffamily qualcosa}»;
10 + «{\em \sffamily qualcosa}»;
«{\em \sffamily qualcosa}» + 10;
if («{\em \sffamily qualcosa}») { ... }
while («{\em \sffamily qualcosa}») { ... }
$persone[«{\em \sffamily qualcosa}»] = «{\em \sffamily qualcos'altro}»;
\end{lstlisting}
\end{frame}
%$

\begin{frame}[fragile]\frametitle{Contesto lista: esempi}
\begin{lstlisting}[escapeinside=«»]
@persone = «{\em \sffamily qualcosa}»;
($primo, $secondo) = «{\em \sffamily qualcosa}»;
($primo) = «{\em \sffamily qualcosa}»;
push @totali, «{\em \sffamily qualcosa}»;
print «{\em \sffamily qualcosa}»;
foreach my $nome («{\em \sffamily qualcosa}») { ... }
\end{lstlisting}
\end{frame}

\begin{frame}[fragile]\frametitle{Contesto scalare: casi particolari}
\begin{itemize}
\item un array in contesto scalare restituisce il numero di elementi: \lstinline!my @a=('a'..'z');my $c=@a;print $c! scrive \lstinline!26!
\item una {\em lista} in contesto scalare restituisce l'ultimo elemento (e spesso genera warning): \lstinline!my $a=qw(a b c);print $a! scrive \lstinline!c!
\end{itemize}
\end{frame}

\begin{frame}[fragile]\frametitle{Contesto lista: casi particolari}
\begin{itemize}
\item \lstinline!my @a=(1..10);@a=()! svuota l'array
\item \lstinline!my @a=(1..10);@a=undef! {\em non} svuota: \lstinline!@a! contiene un elemento, il cui valore è \lstinline!undef!
\end{itemize}
\end{frame}

\begin{frame}[fragile]\frametitle{Forzare il contesto}
\begin{lstlisting}
my @a;print scalar @a; # forza contesto scalare

# forza contesto lista, e assegna a scalare
my $lunghezza=()=funzione_lista();
\end{lstlisting}
\end{frame}
%$

\begin{frame}[fragile]\frametitle{Input in contesto lista}
\begin{lstlisting}
my @linee=<>;  # legge tutto l'input in memoria
chomp(@linee); # toglie tutti gli "a capo"
\end{lstlisting}

\visible<2->{{\em Non} fatelo se non siete sicuri che l'input sia piccolo}
\end{frame}


\section{Hash}

\subsection{Indici}

\subsection{Valori}

\subsection{Funzioni}

\section{Subroutine}

\subsection{Definizione}

\subsection{Invocazione}

\subsection{Argomenti e valore di ritorno}

\subsection{Variabili lessicali}

\section{Input/Output}

\subsection{Qualche dettaglio in più}

\subsection{Le magie di \texttt{<>}}

\subsection{\texttt{printf}}

\subsection{Codifiche}

\section{Espressioni regolari}

\subsection{Cosa sono}

\subsection{Casi semplici} % literal, simple charclass, repetition

\subsection{Operatori più complessi} % anchors, parens, complex charclass (\p)

\subsection{Uso generale} % m, s, split, =~, options

\section{Controllo del flusso}

\subsection{Controlli negati} % unless, until

\subsection{Modificatori}

\subsection{\texttt{for}}

\subsection{Controllo dei cicli}

\section{Moduli}

\subsection{Cosa sono}

\subsection{CPAN}

\subsection{Installazione} % CPAN.pm, distribuzioni e local::lib

\section{Filehandle}

\subsection{Leggere e scrivere file}

\subsection{Test sui file}

\subsection{Moduli da usare} % File::Spec, Path::Class

\section{Directory}

\subsection{Le funzioni} % opendir, readdir

\subsection{Moduli da usare} % File::Find, File::Find::Rule, File::Find::Next

\section{Processi}

\subsection{Le funzioni} % system, exec, qx, fork/wait

\subsection{Moduli da usare} % IPC::Run

\section{Argomenti avanzati}

\subsection{Variabile implicita} % $_

\subsection{Manipolazione di stringhe} % substr, sprintf

\subsection{Manipolazione di liste} % reverse, sort, grep, map

\subsection{Indici multipli} % array & hash slices

\end{document}

% - 
% Local Variables:
% mode: outline-minor
% outline-regexp: "\\(. -+ \\)\\|\\\\part\\|\\\\section\\|\\\\subsection"
% coding: iso-8859-1
% tex-command: "pdflatex"
% tex-main-file: "corso.slides.tex"
% End:
