Syntaxe

Defined-or

La syntaxe de Perl 5.10 a été enrichie de plusieurs ajouts provenant de Perl 6. L'une des plus attendue est le fameux defined-or qui permet d'écrire correctement et de manière courte l'affectation d'une valeur par défaut :

    $var = defined $input ? $input : $default;
    $option = $default unless defined $option;

devient maintenant

    $var = $input // $default;
    $option //= $default;

La double barre oblique // a été retenue comme symbole pour sa ressemblance avec la double barre verticale ||, ce qui permet de se souvenir facilement que cela fait pareil, sauf que cela marche dans tous les cas (puisque || ne sait pas différencier une valeur fausse d'une valeur non définie).

`say`

Autre ajout venu de Perl 6, la fonction say fonctionne comme print, mais en ajoutant un saut de ligne à la fin. C'est donc similaire à la fonction println() de Pascal et Java, mais en plus court, ce qui est utile pour les unilignes (et les adeptes du golf).

    say "OH HAI";    # équivalent à :  print "OH HAI\n"

Opérations sur les fichiers

On peut noter deux petits ajouts en matière d'opérations sur les fichiers. D'une part, on peut maintenant empiler les tests comme -f, -s, ce qui permet de gagner en concision. Ainsi, pour vérifier qu'un chemin est un fichier accessible en écriture et exécution, on pourra écrire -f -w -x $file là où il fallait écrire -f $file && -w _ && -x _. D'autre part, les fonctions chdir(), chmod() et chown() fonctionnent maintenant sur les descripteurs de fichiers si votre système le permet.

Smart match

Encore une fonctionnalité importée de Perl 6, le smart match ou comparaison avancée. Derrière ce nouvel opérateur booléen ~~ se cache un mécanisme assez puissant mais pas totalement facile à maîtriser, qui permet de comparer deux éléments de manière totalement générique. On ne peut guère que traduire et commenter la table de correspondance de perlsyn qui détaille son fonctionnement en fonction du type de chaque opérande. Il faut noter à l'avance que cet opérateur est toujours commutatif ($a ~~ $b est toujours équivalent à $b ~~ $a) et que la première règle de la table qui s'applique détermine son comportement.

  Type $a Type $b   Type de correspondance   Code équivalent
  ======= =======   ======================   ===============
  code[1] code[1]   égalité des références   $a == $b
  autre   code[1]   scalar sub truth         $b->($a)

  hash    hash      clés de hash identiques  [sort keys %$a]~~[sort keys %$b]
  hash    tableau   existence d'une tranche  grep {exists $a->{$_}} @$b
  hash    regex     grep des clés du hash    grep /$b/, keys %$a
  hash    autre     existence d'une entrée   exists $a->{$b}

  tableau tableau   tableaux identiques[2]
  tableau regex     grep du tableau          grep /$b/, @$a
  tableau nombre    nombre dans tableau      grep $_ == $b, @$a
  tableau autre     chaîne dans tableau      grep $_ eq $b, @$a

  autre   undef     indéfini                 !defined $a
  autre   regex     correspondance de motif  $a =~ /$b/
  code()  code()    résultats identiques     $a->() eq $b->()
  autre   code()    simple closure truth     $b->()  # $a est ignorée
  nombre  nombre[3] égalité numérique        $a == $b
  autre   chaîne    égalité de chaîne        $a eq $b
  autre   nombre    égalité numérique        $a == $b 

  autre   autre     égalité de chaîne        $a eq $b

[1] Ce doit être une référence de code dont le prototype (s'il existe) n'est pas vide. Les fonctions avec un prototype vide sont traitées par les règles code().

[2] C'est-à-dire que chaque élément correspond à l'élément de même index dans l'autre tableau. Si une référence circulaire est détectée, on revient à l'égalité des références.

[3] Un vrai nombre ou une chaîne qui ressemble à un nombre.

Le code équivalent indiqué dans cette table n'est bien sûr que pour illustrer, le véritable code s'arrêtant dès que c'est possible.

On le voit, si certaines règles sont simples à comprendre, d'autres sont déjà plus subtiles. On voit néanmoins que certaines opérations qui avant demandaient pas mal de code vont s'en trouver simplifiées. Ainsi, pour vérifier si deux tableaux sont identiques :

    say "ces tableaux sont ", \@a ~~ \@b ? "identiques" : "différents";

`given .. when`

Perl 5.10 propose une construction similaire au switch présent dans bien des langages, mais ici bien plus puissante car, s'appuyant sur la comparaison avancée, elle permet des tests bien plus complexes que ceux possibles avec switch. Plus exactement, cette construction se compose ainsi :

given (EXPR) affecte la valeur de l'expression à $_.
when (EXPR) évalue l'expression comme une condition booléenne. La manière exacte d'évaluer cette condition dépend de ce que contient l'expression, mais en général, given($value) est équivalent à given($_ ~~ $value). Il y a plusieurs exceptions indiquées dans perlsyn mais on peut résumer en disant que cela fonctionne généralement comme on s'y attend.
default correspond comme on peut s'y attendre aux autres cas, si aucune condition when n'a été vérifiée.

Pour simplifier l'utilisation, lorsqu'une condition when se vérifie, on sort du given en même temps que du bloc correspondant. C'est l'inverse du switch en C où il faut explicitement indiquer break en fin de chaque case. On peut toutefois contrôler plus finement le flux d'exécution avec les mots-clés break pour sortir du given et continue pour transférer l'exécution au when suivant. Bien sûr, les conditions when sont examinées dans l'ordre, et c'est la première qui se vérifie qui est exécutée.

Cela peut paraître complexe, mais c'est en fait assez naturel et on peut aussi bien reproduire le switch du C :

    given ($number) {
        when (42) { say "La Réponse"   }
        when (56) { say "fer standard" }
    }

que le case..esac du Bourne shell (sauf qu'on peut utiliser des expressions régulières) :

    use Regexp::Common qw/net/;

    given ($host) {
        when ("localhost"       ) { say "adresse locale" }
        when (/$RE{net}{IPv4}/  ) { say "adresse IPv4"   }
        when (/$RE{net}{domain}/) { say "FQDN"           }
        default { say "type d'argument inconnu" }
    }

Mais l'intérêt réside bien sûr dans l'exploitation du smart match, et du fait qu'on n'est nullement limité dans le type des arguments et des données de comparaison.

    my @primes = (
        2,  3,  5,  7,  11, 13, 17, 19, 23, 29, 31, 37, 41, 43,
        47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97
    );

    given ($value) {
        when ( undef ) {
            say "valeur non définie"
        }
        when ( 42 ) {
            say "La Réponse"
        }
        when ( $_ >= 0 && $_ < 100 ) {
            when ( @primes ) {
                say "petit nombre premier"
            }
            default {
                say "n'est pas un petit nombre premier"
            }
        }
        when ( /$RE{net}{IPv4}/ ) {
            say "adresse IPv4"
        }
        when ( \&is_leap_year) {
            say "$value est une année bissextile"
        }
        default {
            say "type de valeur non géré"
        }
    }

L'exemple est bien sûr un peu artificiel, mais il montre déjà une partie des possibilités de comparaison de cette nouvelle construction, et illustre le fait qu'on peut même imbriquer les when.

Il faut par contre noter que suite à des problèmes pour partie techniques, l'opérateur de comparaison avancé et given .. when, bien qu'à la base inspirés par Perl 6, sont au final différents de leurs équivalents dans le futur langage, tant sur le plan de la syntaxe que sur le plan des sémantiques. Par exemple, le ~~ de Perl 5.10 est commutatif alors qu'en Perl 6 ce n'est pas le cas, et la gestion des tableaux est assez différente.

Plus ennuyeux, cela ne marche pour le moment qu'avec les données de base. Les objets, la surcharge et en général la magie ne fonctionnent pour le moment pas avec la comparaison avancée (et donc given .. when), qui regarde actuellement la structure sous-jacente au lien d'invoquer les appels corrects.

Variables d'état

Pour répondre à certains besoins, une nouvelle classe de variables a été introduite, les variables d'état. Déclarées avec le mot-clé state, elles sont comme les variables my seulement visibles dans leur portée lexicale, mais contrairement à ces dernières, leur valeur est persistante et se conserve d'un appel sur l'autre. Elles sont donc comparables aux variables static en C. Petit exemple trivial qui affiche les cinq premières puissances de 2 :

    sub next_power {
        state $x = 1;   # n'est affecté qu'au premier appel
        return $x <<= 1
    }

    say next_power() for 1..5

Avant, on aurait utilisé un fermeture pour ce genre de code. Cela marchait bien (et cela marche toujours), mais state permet d'éviter certains coûts en mémoire et en complexité associés aux fermeture.

Cela fonctionne aussi pour les tableaux et les hashes, mais on ne peut dans ce cas pas réaliser d'affectation initiale.

    accumulate($_) for 1..5;

    sub accumulate {
        state @values;
        my $value = shift;
        push @values, $value;
        say "values: @values";
    }

Par contre, pas de problème avec les objets :

    use IO::File;

    log_msg("OH HAI");
    log_msg("IM IN UR LOG");
    log_msg("KTHX BAI");

    sub log_msg {
        state $fh = new IO::File "mylog", "w";
        my $msg = shift;
        $fh->print("$msg\n");
    }

Activation de ces nouveautés

Comme certaines de ces nouvelles fonctionnalités pourraient casser du code existant, elles sont désactivées par défaut, et peuvent être activées à la demande avec la pragma lexicale C. Les fonctionnalités ainsi contrôlables sont C, C et C. Pour simplifier, on peut aussi utiliser le raccourci C qui indique de toujours autoriser tous les nouveaux ajouts de S Et comme cela ne fonctionne qu'à partir de cette version du langage, C a le même effet.

Pour les unilignes, l'option C<-E> est équivalente à C<-e>, mais active aussi les ajouts de S

    perl -E 'say "OH HAI WORLD"'

`$_` lexical

La variable $_ peut maintenant être lexicalisée avec my, afin d'être sûr de limiter des modifications à cette variable au seul bloc lexical de travail.

Prototype `_`

Le prototype _ a été ajouté. Il est équivalent au prototype $ mais utilisera $_ si aucune variable n'est passée en argument. Pour cette raison, il ne peut être utilisé qu'en fin de prototype ou avant un point-virgule.

Blocs `UNITCHECK`

Les adeptes de vérification poussée ou de code automodifiant disposent maintenant des blocs UNITCHECK, similaires aux blocs CHECK (ils sont exécutés en fin de la phase de compilation de l'unité qui les définit), mais qui sont exécutés durant les évaluations dynamiques alors que les blocs CHECK ne l'étaient que durant la phase de compilation initiale.

Pragmas lexicales

Il est maintenant possible d'écrire facilement des pragmas lexicales, c'est-à-dire qui se comportent comme strict et warnings et limitent leurs effets aux blocs lexicaux d'où elles sont invoquées. Cela consiste principalement à utiliser le hash %^H pour stocker son état au moment de la compilation, et à le récupérer plus tard, à l'exécution, grâce à caller().

Rafaël Garcia-Suarez a écrit la pragma encoding::source à la fois à titre d'exemple, et aussi pour remplacer la pragma encoding jugée insatisfaisante. Cela permet de mélanger au sein d'un même fichier du texte écrit dans différents encodages :

    use encoding::source "utf8";
    # le code écrit ici est en UTF-8

    {
        use encoding::source "latin-1";
        # mais celui dans ce bloc est en ISO-Latin-1
    }

    # et là on revient en UTF-8

À utiliser avec parcimonie, pour éviter de s'arracher les cheveux !

Voir aussi perlpragma et la documentation de caller() pour plus de détails concernant l'implémentation des pragmas lexicales.

Les nouveautés de Perl 5.10 - première partie

Chapeau

Pourquoi une si longue attente ?

Ce qui a été supprimé

Syntaxe

Defined-or

`say`

Opérations sur les fichiers

Smart match

`given .. when`

Variables d'état

Activation de ces nouveautés

`$_` lexical

Prototype `_`

Blocs `UNITCHECK`

Pragmas lexicales

Objets

`UNIVERSAL::DOES`

`Hash::Util::FieldHash`

Algorithme de résolution C3

Optimisations

Sécurité

Modules

Autres améliorations

Conclusion

Auteur

Les nouveautés de Perl 5.10 - première partie

Chapeau

Pourquoi une si longue attente ?

Ce qui a été supprimé

Syntaxe

Defined-or

say

Opérations sur les fichiers

Smart match

given .. when

Variables d'état

Activation de ces nouveautés

$_ lexical

Prototype _

Blocs UNITCHECK

Pragmas lexicales

Objets

UNIVERSAL::DOES

Hash::Util::FieldHash

Algorithme de résolution C3

Optimisations

Sécurité

Modules

Autres améliorations

Conclusion

Auteur

`say`

`given .. when`

`$_` lexical

Prototype `_`

Blocs `UNITCHECK`

`UNIVERSAL::DOES`

`Hash::Util::FieldHash`