[Toulouse-pm] Les nouvelles fraiches du jour

[Michel Rodriguez]

Salut,

Le synopsys 6: http://www.perl.com/pub/a/2003/04/09/synopsis.html

Les synopsys c'est la version simplifiee des apocalypses par Damian
Conway (et Allison Randal pour celui-ci). Le 6 couvre donc les
fonctions. Au passage il donne aussi plein de details sur les types de
variables.

C'est a mon avis beaucoup plus lisible que l'apocalypse: c'est deja
beaucoup plus court, c'est plus l'equivalent d'un man alors que
l'apocalypse est plus l'equivalent d'une spec.

Le principe general est que par defaut on peut utiliser la meme syntaxe
qu'avec Perl 5, avec le meme comportement. 

Il y a juste un changement, si je ne me trompe (corrigez moi sinon), on
ne doit pas pouvoir modifier les parametres directement. Au cas ou vous
auriez oublie, avec perl 5, les elements de @_ sont des alias vers les
variables d'origine, donc on peut les modifier dans la sub:

perl -le'$var=1; inc( $var); print "var: $var"; sub inc { $_[0]++; }'

En plus, par rapport a perl 5, on peut preciser le type des parametres,
si ils sont passes par valeur (le defaut) ou par addresse (pour pouvoir
les modifier), si ils sont nommes...

En gros on peut garder la simplicite de perl 5, mais on peut aussi aller
tres loin dans le detail des types de parametres passes ou retournes.
Les fans de quasiment tous les autres langages apprecieront le fait
qu'on peut aussi nommer les parametres ce qui evite le celebre my(
$toto, $tata, @tutu)= @; en debut de fonction. Les parametres nommes
sont aussi bien supportes (ce sont les parametres qu'en perl 5 on passe
comme hash, ou hashref

Perl 6 reste faiblement type, ou comme je l'ai lu "fortement type mais
avec des types generiques" ou un truc comme ca, mais optionellement on
peut specifier le type des variables, ce qui facilite la detection des
bugs et permet de gagner de la place en memoire (si une variable est
declaree comme un entier ca evite de se trainer la structure complete
entier/chaine par exemple). 


J'aime bien aussi les "pipe operators", fruits de discussions
interminables sur p6-language:

    grep { $_ % 2 } <== @data;
    @data ==> grep { $_ % 2 };

ca permet d'ecrire plus naturellement, dans l'ordre, des chaines de
transformations comme la celebre "Schwartzian transform":

(non teste, j'ai pas de parl6 sous la main!)

   my @sort= @tableau ==> map  { [calcul_index, $_]  }
                      ==> sort { $a->[0] <=> $b->[0] } 
                      ==> map  { $_->[1] };

  (a partir de la liste on cree une nouvelle liste de paires
index/element de depart, on la trie sur les index et au final on ne
garde que les elements de depart. ca permet de limiter le nombre de fois
ou on calcule l'index, une fois par element au lieu de une fois par
comparaison, c'est utile si le calcul de l'index est long)

En perl 5 c'est moins naturel, il faut le lire en partant de la derniere
ligne:

  my @sort= map  { $_->[1] }
            sort { $a->[0] <=> $b->[0] }
            map  { [calcul_index, $_]  } @tableau;

D'autres trucs rigolos: on peut non seulement quitter la fonction en
cours avec return, mais aussi remonter plus loin dans la pile des
fonctions:

leave &foo <== 1,2,3;   # Return from innermost surrounding call to &foo

donc si on est dans toto, appele par tata, appele par foo, appele par
bar, ca fait l'equivalent de return( 1, 2, 3)... dans foo! l'execution
continue dans bar! C'est clair?

En vrac: on peut remplacer temporairement une fonction par une autre,
mettre un wrapper autour d'une fonction (excellent pour ecrire des
tests!) et puis il y a le "currying", qui permet de creer une nouvelle
fonction, basee sur une fonction existante, mais ou certains parametres
sont deja fixes. C'est une evolution des closures si j'ai bien compris.

Voila, donc plein de trucs a lire, et de beaux meaux de tetes en
perspectives!

Pour finir plus legerement, un lien rigolo (merci a Stephane de
paris.pm): RMS aime parrot  http://www.stallman.org/parrot-love.jpg

Tschao

-- 
Michel Rodriguez <mirod at xmltwig.com>