Perl 6 Introduzione

Perl 6 è un linguaggio gradualmente tipizzato, di alto livello, di uso generale. Perl 6 è multiparadigmatico. Supporta sia programmazione procedurale che orientatata agli oggetti che funzionale.

Per installare Rakudo Star, lancia questi comandi dal tuo terminale:

Per altre opzioni, vai a https://rakudo.org/star/source

Ci sono quattro opzioni:

Eseguire codice Perl 6 può essere fatto usando REPL (Read-Eval-Print Loop). Per farlo apri un terminale, digita perl6 e premi [Enter]. Questo farà apparire il prompt >. Poi digita una linea di codice e digita [Enter]. REPL fornirà il valore della linea. Puoi digitare un’altra linea, oppure exit e premere [Enter] per uscire da REPL.

Alternativamente, scrivi il tuo codice in un file, salvalo e fallo girare. Si raccomanda che gli script Perl 6 abbiano l’estension .pl6. Fai girare il file digitando perl6 nomefile.pl6 nel terminale e premi [Enter]. A differenza di REPL, questo non scriverà automaticamente il risultato di ogni linea: il codice deve contenere una istruzione opportuna (per esempio say) per scrivere un output sul monitor.

REPL in generale si usa per fare delle prove su pezzetti specifici di codice, tipicamente singole linee. Per programmi con più di una singola linea si raccomanda di scriverle prima in un file e poi far girare quello.

Linee singole possono essere provate anche non interattivamente sulla linea di comando attaverso il comando perl6 -e 'tuo-codice-qui' e premendo [Enter].

Poiché scriveremo e salveremo il nostro codice Perl 6 per la maggior parte del tempo, dovremmo avere un buon editor di testo che riconosca la sintassi Perl 6.

Personalmente uso e raccomando Atom. Si tratta di un moderno editor di testo che fornisce nativamente riconoscimento sintattico di Perl 6

Perl 6 FE è un altro riconoscitore sintattico di Perl 6 per Atom; è derivato da un package originale corretto e riveduto.

Altre persone della comunità usano anche Vim, Emacs oppure Padre.

Versioni recenti di Vim forniscono il riconoscimento sintattico nativamente. Emacs e Padre richiederanno invece l’installaizone di package addizionali.

Inizieremo dal tradizionale 'salve mondo'

che può anche essere scritto così:

Perl 6 è free form: Sei libero (la maggior parte delle volte) di usare un numero di spazi a piacere.

Istruzioni sono tipicamente una linea logica di codice, necessitano di finire con punto e virgola: say "Ciao" if True;

Espressioni sono speciali tipi di istruzioni che ritornano un valore: 1+2 restituirà 3

Le espressioni sono composte da Operandi ed Operatori

Gli operandi possono essere:

Gli operatori vengono classificati nei seguenti tipi:

Nella tabella qui sotto vediamo gli operatori più comunemente usati.

Aggiungendo una R prima di ogni operatore si rovesceranno i suoi operandi.

Gli operatori di riduzione lavorano su liste di valori. Si formano avvolgendo l’operatore tra parentesi quadre []

Gli scalari portano un singolo valore oppure un puntatore.

Sugli scalari si può applicare un gruppo specifico di operazioni, dipendentemente dal valore che portano.

Gli array (alias vettori, liste etc ndt.) sono liste contenenti valori multipli.

Sugli array si possono fare un sacco di perazioni, come mostrato nell’esempio sottostante:

.elems ritorna il numero degli elementi di un array.
.push() aggiunge uno o più elementi all’array.
Possiamo accedere ad uno specifico elemento dell’array specificando la sua posizione @animali[0].
.pop rimuove l’ultimo elemento dell’array e lo restituisce.
.splice(a,n) rimuove n elmenti iniziando dalla posizione a.

Alcuni metodi che possono essere applicati agli hash:

.push: (chiave => 'valore') aggiunge una nuova coppia chiave/valore.
.kv ritorna una lista contenente tutte le chiavi ed i valori.
.keys ritorna una lista contenente tutte le chiavi.
.values ritorna una lista contenente tutti i valori.
Possiamo accedere ad uno specifico valore nell’hash specificando la sua chaive, così %hash<key>

Nei precedenti esempi non abbiamo specificato che tipo di valori le variabili dovrebbero contenere.

Come puoi vedere nell’esempio qui sopra, il tipo di valore in $var prima era (Str) e poi è diventato (Int).

Questo stile di programmazionie viene chiamato tipizzazione dinamica. Dinamica nel senso che le variabili possono contenere valori di ogni tipo (tipo Any ndt).

Prova a far girare questo esempio:
Nota Int prima del nome della variabile.

Fallirà con questo messaggio di errore: Type check failed in assignment to $var; expected Int but got Str controllo sul tipo fallito per $var; mi aspettavo un Int ma ho ricevuto Str]

Ciò che è successo è che abbiamo specificato che la variabile avrebbe dovuto essere di un tipo (Int), ma quando l’abbiamo assegnata ad una stringa è fallita.

Questo stile di programmazione si chiama tipizzazione statica. Statica nel senso che i tipi delle variablili sono definiti prima degli assegnamenti e non possono più cambiare.

Il Perl 6 è classificato come gradualmente tipizzato; esso permette sia la tipizzazione statica che quella dinamica.

Probabilmente non userai mai i primi due ma essi vengono inclusi in questa lista per completezza.

Introspezione è il processo per cui si ottiene una informazione sulle proprietà di un oggetto, come il tipo.
In un esempio precedente abbiamo usato .WHAT per ottenere il tipo di una variabile.

Il tipo di una variabile che contiene un valore è correlato a tale valore.
Il tipo di una variabile vuota dichiarata staticamente è il tipo con il quale è stata dichiarata.
Il tipo di una variabile vuote che non è stata dichiarata staticamente è (Any)
Per cancellare il valroe di una variabile assegnale Nil.

Prima di usare una variabile per la prima volta essa deve essere dichiarata.

Ci sono molti dichiaratori in Perl 6. Finora abbiamo usato il my.

Il my fornisce alla variabile un ambito lessicale. In altre parole la variabile sarà accessibile nel nello stesso blocco in cui è stata dichiarata.

Un blocco in Perl 6 è delimitato dalle parentesi graffe { }. Se non ci sono blocchi la variabile sarà disponibile nell’intero script.

Dato che una variabile è accessibile nel blocco dove viene definita, lo stesso nome di variabile può tranquillamente essere usato in un altro blocco.

Abbiamo visto negli esempi precedenti come assegnare valori alle variabili.
Un *assegnamento viene fatto tramite l’operatore =.

IL valore assegnato ad una variabile si può cambiare:

D’altro canto, non possiamo cambiare il valore di una variabile quando questo è vincolato.
Il vincolo viene definito tramite l’operatore :=.

Vincolare le variabili è bidirezionale.
$a := $b and $b := $a hanno lo stesso effetto.

Il codice gira solo se la condizione specificata viene soddisfatta, ossia una espressione viene valutata come True.

In Perl 6, possiamo invertire il codice condizionato e la condizione.
Anche se il codice e la condizione vengono invertiti, la condizione viene sempre valutata per prima.

Se la condizione non viene soddisfatta, possiamo specificare blocchi da eseguire in alternativa usando:

La versione negata di una istruzione if può essere unless.

Il codice seguente:

può essere scritto così:

La negazione, in Perl 6, viene fatta usando o ! o not.

unless (codizione) viene usato al posto di if not (condizione).

unless non può avere una clausola di alternativa else.

with si comporta come if, ma controlla se la variabile sia definita.

Se fai girare il codice senza assegnare una valore alla variabile, non accade nulla.

without è la versione negata di with. Puoi vederne un’analogia di unless.

se il primo with non viene soddisfatto, si può specificare un percorso alternativo con orwith.
with ed orwith sono analoghi ad if ed elsif.

Il ciclo for itera su valori multipli.

Nota che abbiamo creato una variabile di iterazione $array-item e poi eseguito l’operazione *100 su ogni occorrenza della stessa.

given è l’equivalente Perl 6 dell’istruzione switch che si trova in altri linguaggi, ma molto più potente.

A seguito di una condizione soddisfatta, il processo di confronto si interrompe.

L’alternativa è usare proceed che dice a Perl 6 di continuare i confronti anche dopo un successo.

loop è un altro modo di scrivere un ciclo for.

In realtà loop sarebbe il for per come è scritto nei linguaggi di programmazione della famiglia che si rifà al C.

Infatti il Perl 6 appartiene a tale famiglia.

Si possono usare due subroutine per far girare comandi shell:

echo ed ls sono comandi Linux:
echo stampa un testo su terminale (equivalente a say in Perl 6)
ls lista tutti i file e le cartelle del direttorio corrente

dir equivale a ls quando sei su Windows.

Perl 6 può listare il contentuo di una cartella senza ricorrere alla shell di comando (per esempio se vogliamo fare un ls).

In oltre puoi creare e cancellare cartelle.

Puoi anche controllare se un certo percorso esista; puoi controllare se sia un file, oppure una cartella:

Nella cartella dove farai girare lo script sottostante, crea prima una sottocartella vuota chiamata cartella123 e crea anche un file vuoto chiamato script123.pl6

IO.e controlla che la cartella o il file esistano.
IO.f controlla che il percorso sia un file.
IO.d controlla che il percorso sia una cartella.

Le Subroutine (chiamate anche sub o funzioni o procedure o metodi) sono strumenti per riutilizzare delle specifiche funzionalità.

La definizione di una subroutine inizia con la parola chiave sub. Dopo la loro definizione possono essere chiamate tramite il loro identificativo.
Prova questo esempio:

L’esempio precedente mostra una subroutine che non richiede alcun input.

Le subroutine possono richiedere un input. Tali input vengono forniti tramite argomenti. Gli argomenti sono anche detti parametri. Il numero ed il tipo di parametri che una subroutine definisce viene chiamato firma.

La subroutine qui sotto accetta un argomento di tipo stringa.

Ci possono essere subroutine che hanno lo stesso nome ma firme diverse. Quando si chiama una subroutne, l’ambiente di esecuzione decide quale versione usare basandosi sul numero e sul tipo degli argomenti forniti. Questo tipo di subroutine è definito nello stesso modo con cui si definiscono le normali sub eccetto per il fatto che usiamo la parola chiave multi al posto dell’originale sub.

Se una subroutine viene definita per accettare un argomento e noi invece la chiamiamo senza fornire tale argomento avremo un fallimento.

Perl 6 allora fornisce la possiblilità di definire:

I parametri opzionali vengono definiti aggiungendo ? al nome del parametro.

Se non hai bisogno di fornire un argomento, puoi definirne uno in caso di mancanza.
Per farlo assegni un valore al tuo parametro in fase di definizione.

Tutte le subroutine che abbiamo visto fanno qualcosa — scrivono del testo al terminale.

Talvolta, tuttavia, eseguiamo subroutine perché ci restituiscano un valore con il fino di usarlo nei passi successivi del nostro programma.

Se una funzione giunge alla fine del suo blocco, l’ultima istruzione o espressione determinerà il valore di ritorno; è il ritorno implicito

Per leggibilità e pulizia del codice, potrebbe essere bene specificare esplicitamente che cosa viene restituito; usiamo allora la parola chiave return; è il ritorno esplicito

I metodi sono cittadini di prima classe:

Un ottimo esempio di questo è la funzione map.
map è una funzione di alto livello, può accettare un’altra funzione come agomento.

Abbiamo definito la subroutine quadrato che prende un argomento e lo eleva al quadrato.
Poi abbiamo usato map, una funzione di alto livello, e le abbiamo passato due argomenti: la funzione quadrato ed un vettore di interi.
Il risultato è un vettore di elementi al quadrato.

Nota che per passare la funzione come argomento abbiamo avuto bisogno di anteporle &.

Una funzione anonime non è legata ad un identificatore, non ha un nome. Una funzione anonima si chiama anche lambda.

Proviamo a riscrivere l’esempio map ed usiamo una funzione anonima

Nota che invece di dichiarare la funzioine quadrato e passarla come argomento a map abbiamo invece definitio questa funzione anonima -> $x {$x ** 2}.

Nel gego del Perl 6 quesa notazione si chiama blocco a punta.

In Perl 6 i metodi possono essere concatenati: in tal modo non è più necessario passare il risultato di un metodo ad un altro come argomento.

Per esempio: Dato un array, puoi voler ritornare i valori unici dell’array, ordinati dal maggiore al minore.

Questa è la soluzione senza concatenazione:

Qui chiamiamo la procedura unique su @array, e passiamo il risultato come argomento a sort, e poi passiamo il risultato a reverse.

Al contrario, usando i metodi concatenati, l’esempio sopra può essere riscritto così:

molto più leggibile!

L' operatore alimentazione, chiamato pipe in alcuni linguaggi di programmazione funzionale, illustra ulteriormente le tecniche di concatenazione.

Qui il metodo delle chiamate è top-down — dal primo passo all’ultimo.

Nella sostanza l’alimentazione inversa è identica a quella in avanti.
Il flusso si inverte, dal passo finale al primo passo.

L' operatore iper >>. chiama un metodo su tutti gli elementi di una lista e ritorna la lista dei risultati.

Usando l’operatore iper possiamo chiamare i metodi predefiniti in Perl 6, per esempio is-prime che ci dice se un numero è primo oppure no.
Inoltre possiamo definire nuove subroutine e chiamarle usando l’operatore iper. In questo caso dobbiamo anteporre & al nome del metodo; per esempio &is-even.

Questo è molto comodo e ci solleva dal dover scrivere cicli for per iterare su ogni valore.

Una giunzione è una sovrapposizione logica di valori.

Nell’esempio qui sotto 1|2|3 è una giunzione.

L’uso di giunzioni nomalmente scatena l'autothreading; ossia, l’operazione viene eseguita per ogni valore della giunzione e tutti i risultati vengono combinati in una nuova giunzione e ritornati.

Una lista pigra è una lista che viene valutata con pigrizia.
Valutare con pigrizia significa ritardala la valutazione di una espressione fino a che essa non venga richiesta ed evita di ripetere valutazioni su valutazioni immagazzinando i risultati in una tabella predittiva.

I benefici includono:

Per costruire una lista pigra usiamo l’operatore …​
Una lista pigra ha uno o più elementi iniziali, un generatore ed un punto finale.

L’elemento iniziale è 1 ed il punto finale è 10. Qui non viene definito alcun gneeeratore quindi il generatore è il successore (+1)
In altre parole la lista pigra può ritornare (se richiesti) i seguenti elementin (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

Questa può ritornare (se richiesto) un intero tra 1 ed infinito, in altre parle un numero naturale.

Gli elementi iniziali sono 0 e 2 ed il punto di fine è 10. Non viene definito alcun generatore, ma usando gli elementi iniziali, Perl 6 dedurrà che il generatore è (+2)
Questa lista pigra può ritornare (se richiesti) i seguenti elementi (0, 2, 4, 6, 8, 10)

In questo esempio abbiamo definito esplicitamente il generatore abbacciandolo tra le { }
Questa lista pigra può ritornare (se richiesti) i seguenti elementi (0, 3, 6, 9, 12)

Tutti gli oggetti di Perl 6 sono chiusure, ossia essi possono riferirsi a variabili lessicali da un ambito più esterno.

Quando fai girare il codice qui sopra, esso scriverà Buongiorno Giovanni Dossi sul terminale.
Mentre il risultato è giustamente semplice, ciò che è interessante in questo esempio, è che la subroutine interna saluti venga ritornata da una routine esterna prima di essere eseguita.

$saluto-generato è diventata una chiusura.

Una chiusura è uno speciale tipo di oggetto che combina due cose:

L’ambiente consiste in qualsiasi variabile locale che era all’interno dell’ambito al momento in cui la chiusura è stata creata. In questo esempio specifico, $saluto-generato è una chiusura che incorpora sia la funzione saluti che la stringa Giovanni Dossi che esisteva quando la chiusura era stata creata.

Vediamo ora un esempio più interessante.

In questo esempio abbiamo definito un metodo genera-saluti($periodo) che accetta un argomento singolo $periodo e ritorna una nuova funzione. Tale funzione accetta un argomento singolo $nome e ritorna un saluto.

Essenzialmente, genera-saluti è una fabbrica di funzioni. In questo esempio usiamo genera-saluti per creare due nuove funzioni, una dice Buon giorno mentre l’altra dice Buon Natale.

$giorno e $natale sono entrambe delle chiusure. Esse condividono la stessa definizione di corpo, ma si portando dentro ambienti diversi. In $giorno l’ambiente è `$periodo = "giorno". In $natale l’ambiente è $periodo = "Natale"

La programmazione orientata agli oggetti è uno dei paradigmi maggiormente usati oggi.
Un oggetto è un insieme di variabili e funzioni riuniti tutti insieme in una unità.
Le variabili vengono chiamate attributi mentre le funzioni vengono chiamate metodi.
Gli attributi definiscono lo stato mentre i metodi definiscono il comportamento di un oggetto.

Una classe è un modello per creare oggetti.

Per capire le relazioni tra questi concetti considera questo esempio:

Nel gergo orientato agli oggetti diciamo che gli oggetti sono istanze di una classe.

Considera questo script:

La parole chiave class definisce la classe.
has definisce gli attributi di una classe.
Il metodo .new() è detto costruttore. Esso crea l’oggetto come una istanza della classe su cui è stato chiamato.

Nello script riportato qui sopra la nuova variabile $giovanni contiene un puntatore ad una nuova istanza di "umano" che è stata definita con umano.new().
Gli argomenti passati al metodo .new() vengono usati per definire gli attribuiti dell’oggetto sotteso.

L'ambito lessicale di una classe può essere dato tramite my:

L’incapsulazione è un concetto del paradigma agli oggetti; esso racchiude dati e metodi di un oggetto in una unità. I dati (attributi) che si trovano all’interno dell’oggetto dovranno essere privati, ossia accessibili solamente dall’interno dell’oggetto.
Per accedere agli attributi dall’esterno dell’oggetto bisognerà quindi usare speciali metodi detti accessori (ossia che accedono n.d.t).

I due script qui sotto danno lo stesso risultato.

Il metodo sayvar è un metodo accessorio. Ci permette di accedere al valore di una variabile senza entrare in contatto diretto con essa.

L’incapsulazione è facilitata in Perl 6 grazie all’uso dei sigilli secondari.
Si pongono tra il sigillo ed il nome dell’attributo.
Ci sono due tipi di sigilli secondari per le classi:

Tutti gli attributi sono privati, in mancanza di una precisazione diversa, ma è buona pratica usare sempre il sigillo secondario !.

Quindi, dovremmo riscrivere la classe in questa forma:

Aggiungi allo script questa istruzione: say $giovanni.anni;
Essa ti risponderà con un messaggio di errore: Method 'anni' not found for invocant of class 'umano' perché $!anni è privata e può essere usata solo all’interno dell’oggetto. Provando ad accedere ad essa dall’esterno l’oggetto ritorna un errore.

Sostituisci ora has $!anni con has $.anni ed osserva il risultato di say $giovanni.anni;

In Perl 6, tutte le classi ereditano un costruttore base .new().
Esso può essere usato per creare oggetti passandogli degli argomenti.
Il costruttore base accetta solamente argomenti nominali.
Nel nostro esempio qui sopra, nota che gli argomenti passati al costruttore sono definiti tramite un nome di riferimento:

Che accade se io non voglio fornire il nome di ciascun attributo ogni volta che voglio creare un oggetto? Ho bisogno di creare un diverso costrutto, il quale accetti argomenti posizionali.

Gli attributi di classe sono attributi che appartengono alla classe stessa e non ai suoi oggetti.
Essi possono essere inizializzati durante la definizione.
Gli attributi di classe vengono dichiarati usanto my al posto di has.
Sono invocati sulla classe stessa, invece che sugli oggetti.

Fino ad ora tutti gli esempi che abbiamo visto hanno usato accessori per prendere informazioni dagli oggetti.

Che accade se abbiamo bisogno di modificare il valore di un attributo?
Abbiamo bisogno di marcarlo come sia leggibile e scrivibile usando la parola chiave is rw.

In mancanza di specificazioni, gli attributi vengono dichiarati come solo leggibili non scrivibili, ma questo tipo di accesso si può anche specificare esplicitamente tramite la parola chiave is readonly.

L’ereditarietà multipla è supportata in Perl 6. Una classe può ereditare da svariate classi.

La classe grafico-combinato dovrebbe essere in grado di gestire le due serie, quella dei valori correnti tracciati sulle barre, e quella dei valori previsti tracciati tramite linee.
Questo perché abbiamo definito una figlia di grafico-a-linee e di grafico-a-barre.
Dovresti aver notato che invocare il metodo traccia sulla classe grafico-combinato non porta il risultato richiesto. Soltanot una serie viene tracciata.
Perché?
grafico-combinato eredita da grafico-a-linee e da grafico-a-barre, le quali possiedono entrambe un metodo chiamato traccia. Quando invochiamo il metodo su grafico-combinato Perl 6, internamente, cerca di risolvere il conflitto chiamando uno dei due metodi.

Per avere il comportamento corretto dobbiamo fare l’override del metodo traccia all’interno di grafico-combinato.

I ruoli sono simili alle classi per il fatto che essi sono collezioni di attributi e metodi.

I ruoli vengono dichiarati con la parola chiave role. Classi che vogliono implementare un ruolo debbono usare la parola chiave does.

Fai girare questo script e vedrai che il risultato non muta.

Allora ti chiederai: se i ruoli si comportano come le classi, che senso hanno?
Per rispondere alla domanda modifica il primo script usato per le ereditarietà multiple, quello dove abbiamo dimenticato di fare l’override del metodo traccia.

Il metodo traccia deve essere risolto dalla classe grafico-combinato poiché esso esiste in ruoli multipli (grafico-a-linee, grafico-a-barre)

Se i ruoli multipli vengono applicati alla stessa classe e si presenta un conflitto, si genera un errore durante la compilazione del codice.
Questo risulta essere un approccio molto più sicuro rispetto alla semplice eredità multipla, dove i conflitti non vengono conderati errori e vengono risolti (in qualche modo) in fase di esecuzione.

I ruoli ti avvisano che c’è un conflitto.

L'introspezione è il processo di estrarre l’informazione su un oggetto, come per esempio quale sia il suo tipo, i suoi attributi o i suoi metodi.

L’introspezione è facilitata da:

Le eccezioni sono eventi speciali che accadono durante l’esecuzione del programma quando qualche cosa va storto.
In questi casi si dice che le eccezioni vengono scatentate.

Considera lo script qui sotto, esso gira correttamente:

Ora considera questo script, che scatena una eccezione:

Fallimento nel controllo sui tipi durante l’assegnamento a $nome; mi aspettavo Str ma ho ricevuto Int nel blocco <unit> in <nome script>.pl6:2

Notiamo che tutte le volte che accade un errore (in questo caso assegnando un numero ad una variabile stringa) il programma si ferma e la successiva linea di codice non viene neppure valutata.

la gestione delle eccezioni è il processo di cattura di una eccezione che è stata scatenata con il fine di permettere allo script di proseguire.

La gestione delle eccezioni si implementa con un blocco try-catch (prova e cattura, n.d.t.).

Il blocco CATCH può essere definito nello stesso modo in cui viene definito un blocco given; ossia possiamo catturare e gestire diversi tipi di eccezioni. Ecco un esempio:

Il Perl 6 permette anche di scatenare esplicitamente delle eccezioni.
Si possono scatenare due tipi di eccezioni:

Le eccezioni Ad-hoc vengono scatenate usando la subroutine die, seguita dal messaggio di eccezione.

Le eccezioni tipizzate sono oggetti; per questo abbiamo usato il costruttore .new() nell’esempio.
Tutte le eccezioni tipizzate discendono dalla classe X; qui sotto alcuni esempi:
X::AdHoc il più semplice tipo di eccezione
X::IO errori relativi all’IO
X::OS errori relativi al sistema operativo
X::Str::Numeric errori relativi al tentare di forzare una stringa in un numero

Una espressione regolare può essere definita in questi modi:

Ameno che non sia specificato esplicitamente lo spazio bianco viene ignorato; m/lumi/ and m/ lumi / sono equivalenti.

Caratteri alfanumerici ed il trattino-basso _ vengono scritti normalmente.
Tutti gli altri caratteri debbono essere contrassegnati dal backslash o abbracciati da apici.

I caratteri possono essere classificati in categorie e possiamo riferirci a queste.
Possiamo anche trovare corrispondenze inverse di tali categorie (ossia "tutto tranne questo insieme"):

La corrispondenza con categorie di caratteri, come visto nella precedente sezione, è conveniente.
Detto questo, un approccio più sistematico sarebbe l’uso delle proprietà Unicode.
Queste ti permetttono di trovare corrispondenze tra categorie di caratteri sia all’interno che all’esterno dello standart ASCII.
Le proprietà Unicode sono abbracciate da queste parentesi <: >

I jolly possono essere usati nelle espressioni regolari.

Il punto . indica il singolo carattere.

I quantificatori seguono un carattere e vengono usati per specificare quante volte ce lo aspettiamo.

Il punto di domanda ? significa zero o una volta.

La stellina * indica zero o più volte

Il + indica almeno una volta.

Ogni volta che il processo di corrispondenza ha successo, il risultato viene memorizzato in una variabile speciale $/

$/ ritorna un oggetto corrispondente (la stringa che corrisponde all’espressione regolare)
I metodi seguenti possono essere chiamati sull'oggetto corrispondente:
.prematch ritorna la stringa che precede la corrispondenza.
.postmatch ritorna la stringa che segue la corrispondenza.
.from ritorna la posizione di partenza della corrispondenza.
.to ritorna la posizione finale della corrispondenza.

Controlliamo se una mail è valida o no.
Per semplicità assumiamo che una email valida abbia questo formato.
nome [punto] cognome [chiocciolina] azienda [punto] (com/org/net)

giovanni.dossi@perl6.org è una mail valida

<:L> trova la corrispondenza di una singola lettera
<:L>` trova la corrispondenza con una o più lettere + `\.` trova la corrisondenza con un singolo carattere [punto] + `\@` trova la corrispondenza con un singolo carattere chiocciolina [@] + `<:L:N> trova una singola lettera ho una singola cifra numerica
<:L+:N>+ una o più lettere o numeri

L’espressione regolare può quindi essere decomposta in questo modo:

Una espressione regolare con nome viene definita con questa sintassi: my regex nome-regex { defininizione-regex }
Una espressione regolare con nome può essere chiamata usando questa sintassi: <nome-regex>

MD5 è una funzione di crittografia che produce has a 128-bit.
MD5 ha varie applicazioni, inclusa la codifica di password immagazzinate in un database. Quando un nuovo utente si registra, le sue credenziali non vengono memorizzate come un semplice testo ma piùttosto inserite in un hash. L’idea che sta dietro questa scelta è questa: se il DB viene compromesso, l’attaccante non sarà in gradi di sapere quali sono le password.

Fortunatamente, non devi implementare l’algoritmo MD5 da solo; già esiste un modulo Perl 6 che lo implementa.

Installiamolo:
zef install Digest::MD5

Ora fai girare questo script:

Per far girare la funzione md5_hex() che crea gli has, abbiamo bisono di caricare il modulo richiesto.
La parola chiave use carica il modulo permettendo di usarlo nello script.

Le tre linee qui sopra mostrano diversi modi di costruire un carattere:

La lettera á può essere scritta:

NFC restituisce il codice numerico.
NFD decompone il carattere nei codice numerici che lo compongono.
uniname ritorna il codice nominale in inglese.

In circostanze nomali, tutti i compiti di un programma girano in sequenza.
Questo potrebbe non essere un problema, a meno che tu non stia tentando di perdere molto tempo.

Fortunatamente, Perl 6 fornisce funzionalità che permettono di far girare codice in parallelo.
A questo punto, è importante notare che il parallelismo significa due cose:

Iniziamo da quest ultimo caso.

Considera il codice C sottostante: esso definisce una funzione chiamata hellofromc. Questa funzione stampa sul terminale la stringa Hello from C. Essa non accetta alcun argomento e non restituisce alcun valore.

Dipendendemente dal tuo sistema operativo i seguenti comandi servono per compilare tale codice C all’interno di una libreria.

All’interno della stessa cartello dove hai compilato la tua libreria in C, crea un nuovo file Perl 6 che contene il codice sottostante e fallo girare.

Prima di tutto dichiariamo che useremo il modulo NativeCall.
Poi creiamo una costante LIBPATH che contiene il percorso fino alla libreria C.
Nota che $*CWD restituisce la cartella corrente.
Poi creiamo una nuova funzione Perl 6 chiamata hellofromc() la quale funge da wrapper per la sua controparte C avendo lo stesso nome e risiedendo nella libreria C che si trova in LIBPATH.
Tutto questo viene fatto usando la direttiva is native.
Alla fine invochiamo la nostra subroutine Perl 6.

Alla fine, il tutto si riduce a dichiarare una subroutine con la direttiva is native ed il nome della libreria C.

Nel paragrafo qui sopra, abbiamo visto come possiamo chiamare una funzione C molto semplice wrappandola con una subroutine Perl 6 che ha lo stesso nome, tramite la direttiva is native.

In alcuni casi, potremmo voler cambiare il nome della subroutine Perl 6.
Per farlo usiamo la direttiva is symbol.

Modifichiamo allora il codice Perl 6 qui sopra e rinominiamo la subroutine come hello invece di hellofromc

Nel caso in cui la subroutine Perl 6 abbia un nome diverso dalla sua controparte C, dovremmo usare is symbol con il nome della funzione C originale.

Compila e fai girare la seguente libreria C nello script Perl 6 che trovi ancora più sotto.
Nota come abbiamo modificato sia C che Perl 6 per accettale la stringa (char* in C e Str in Perl 6)

Ripetiamo il processo ancora una volta e creiamo un semplice calcolatore che prende due interi e li somma.
Compila la libreria C e lancia lo script Perl 6.

Nota come entrambi C e Perl 6 accettino due interi e ne restituiscano uno solo. (int in C e int32 in Perl 6)

Potresti chiederti perché abbiamo usato int32 invece di Int nell’ultimo script.
Alcuni tipi del Perl 6, come Int, Rat ecc. non possono essere usati per passare e ricevere valori dalle funzioni C.
Si debbono infatti usare tipi omologhi tra i due linguaggi.

Fortunatamente Perl 6 fornisce molti tipi che si mappano perfettamente con le loro controparti in C.