5.10.0-RC1 le 17 novembre 2007, durant les Journées Perl

5.10.0-RC2 le 25 novembre 2007

5.10.0 le 18 décembre 2007, 20e anniversaire de Perl 1.000

$*, $#

pseudo-hashes

compilateur

JPL

adapté de Perl 6

avant :

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

maintenant :

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

adapté de Perl 6

comme println()

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

tests de fichiers empilables

adapté de Perl 6

    -f -w -x $file

opérations sur les descripteurs de fichiers

• si supporté par l'OS

inspiré de Perl 6

opérateur booléen, commutatif, noté ~~

    if ($a ~~ $b) {
        ...
    }

méthode de comparaison déterminée par le type des arguments

la première règle qui s'applique détermine son comportement

  Type $a Type $b   Type de correspondance   Code équivalent
  ======= =======   ======================   ===============
  code    code      égalité des références   $a == $b
  autre   code      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
  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    é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

basé sur une vieille spécification de Perl 6

différent du smart match de Perl 6 :-(

• commutativité

• comportement sur les tableaux

buggé :-(

• ne marche pas sur les objets sans surcharge de l'opérateur ~~

• ne se comporte pas entièrement comme documenté sur les tableaux et hashes

corrigé dans 5.10.1

• non commutatif

• règle déterminée par le type de l'opérande droite

• objets autorisés seulement si ~~ surchargé

ajouts

• support des intervalles : 4.5 ~~ 3..5

• any ~~ array distribue le test sur le tableau

  Type $a Type $b   Type de correspondance   Code équivalent
  ======= =======   ======================   ===============
  autre   undef     non définit              !defined $a
  
  hash    coderef   code vrai pour chaque clé   !grep { !$b->($_) } keys %$a
  tableau coderef   code vrai pour chaque cas   !grep { !$b->($_) } @$a
  autre   coderef   code vrai pour la valeur    $b->($a)
  
  hash    hash      clés de hash identiques  [sort keys %$a]~~[sort keys %$b]
  tableau hash      existence d'une tranche  grep { exists $b->{$_} } @$a
  regex   hash      grep des clés du hash    grep /$a/, keys %$b
  undef   hash      toujours faux (undef ne peut être une clé)
  autre   hash      existence d'une entrée   exists $b->{$a}
  
  hash    tableau   existence d'une tranche  grep { exists $a->{$_} } @$b
  tableau tableau   tableaux identiques
  regex   tableau   grep du tableau          grep /$a/, @$b
  undef   tableau   tableau contient undef   grep !defined, @$b
  autre   tableau   distrib. du test sur tableau    grep $a ~~ $_, @$b
  
  hash    regex     grep des clés du hash    grep /$b/, keys %$a
  tableau regex     grep du tableau          grep /$b/, @$a
  autre   regex     correspondance de motif  $a =~ /$b/
  
  undef   range     toujours faux
  autre   range     dans l'intervalle
  
  autre   nombre    égalité numérique        $a == $b
  autre   autre     égalité de chaîne        $a eq $b
 -

exemples

    say @a ~~ @b ? "equal" : "not equal";

    %a = ( plonk => "pouet" );
    $b = "plonk";
    say %a ~~ $b ? "true" : "false";    # true

     $a = [1, 2, 3];
     $b = 2;
     say $a ~~ $b ? "true" : "false";   # true
     $b = 5;
     say $a ~~ $b ? "true" : "false";   # false

inspiré de Perl 6

    given (EXPR) {
        when (EXPR) { ... }
        when (EXPR) { ... }
        default     { ... }
    }

given affecte la valeur de l'expression à $_

when évalue l'expression comme une condition booléenne

• en général, équivalent à given ($_ ~~ EXPR)

default si rien d'autre n'a correspondu

contrôle du flux

• un when qui réussit termine le given correspondant

• break pour sortir du given

• continue pour aller au when suivant

exemples

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

    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" }
    }

adapté de Perl 6

nouvelle classe de variables

portée lexicale, mais valeur persistante

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

    say next_power_of_two() for 1..5

fonctionne sur les tableaux et hashes, mais sans initialisation

nouveautés désactivées par défaut pour raisons de compatibilité arrière

activables avec use feature ou use 5.10.0 :

    use 5.10.0;
    say "OH HAI WORLD";

pour les unilignes, utiliser -E :

    perl -E 'say "OH HAI WORLD"'

    for my $_ (@data) {
        ...
    }

similaire au prototype $ mais utilise $_ si aucune variable n'est passée en argument

similaires aux blocs CHECK, mais exécutés après la compilation de chaque unité

stocke son état dans %^H à la compilation

le récupère à l'exécution par caller()

cf. encoding::source :

    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

pas de changements fondamentaux

améliorations pour mieux supporter les nouveaux modèles objets

• objets inversés (inside-out objects)

• traits

• rôles

• méta-modèles

méthode globale DOES()

facile à surcharger

similaire à isa(), mais plus générale et adaptée à la notion de rôle

    if ($dog->DOES("Walkable")) {
        $dog->walk;
    }

module fourni avec Perl 5.10

meilleur support pour les modèles d'objets inversés

Hash::Util::FieldHash::Compat sur le CPAN

terminologie

MRO = algorithme de résolution des méthodes

algorithme classique de Perl : DFS (Depth First Search)

pose problème pour des hiérarchies trivialement complexes

exemple :

      A
     / \
    B   C
     \ /
      D

DFS renvoie : (D, B, A, C)

algorithme de linéarisation à triple cohérence

garantit qu'aucune classe n'apparaît avant une de ses sous-classes

      A
     / \
    B   C
     \ /
      D

C3 renvoie l'ordre correct (D, B, C, A)

utilisé dans Dylan, Python 2.3, Perl 6

DFS reste le MRO par défaut, pour raison de compatibilité

MRO peut être changé avec la pragma mro

    use mro "dfs";  # utilise le MRO DFS pour cette classe
    use mro "c3";   # utilise le MRO C3 pour cette classe

mro fournit aussi plusieurs fonctions et méthodes avancées

• mro::get_linear_isa(), next::method(), next::can()

MRO::Compat et Class::C3 sur le CPAN

fournit l'algorithme sur Perl 5.8

utilise celui natif sur Perl 5.10

beaucoup de refactoring interne

factorisation de structures internes

gain de mémoire

constantes plus légères

constant sur le CPAN et disponible pour Perl 5.5

cas particuliers de sort

•     @a = sort @a   # plus de liste intermédiaire

•     reverse sort ...   # trie à l'envers

fonction de tri peut être récursive

Unicode : opérations améliorées

Unicode : meilleure utilisation du cache

création des références de tableau et hash plus rapide

$AUTOLOAD respecte le taint mode

printf() et sprintf() rejettent les arguments non valides

utilisation de strlcat() et strlcpy()

constification de l'API interne et externe

• char * => const char *

Module::CoreList, corelist

Archive::Tar, Compress::Zlib

Module::Pluggable, Pod::Simple

encoding::warnings

ExtUtils::ParseXS, ExtUtils::CBuilder

Module::Build, CPANPLUS

Exporter, File::Path

constant, Pod::Html

diagnostics plus explicites (quand c'est possible)

• Use of uninitialized value $w in print at -e line 1.

base Unicode 5.0.0

meilleur support pour les OS exotiques

OS EBCDIC : OS/390, z/OS, etc

OpenVMS : support d'ODS-5

Win32 :

• support des noms Unicode (sur NTFS)

• optimisation de stat() (variable ${^WIN32_SLOPPY_STAT})

publié dans Linux Magazine France n°104

http://articles.mongueurs.net/magazines/linuxmag104.html