Perl 6
Perl 6 Tutorial Part 4: Revision 2

=head1 Perl 6 Tutorial - Teil 4 : Hashes und Kontrollstrukturen

=head2 Wieder mal ein Vorwort

Herzlich Willkommen zu Folge 4. Ein Editor der Wahl ist weiterhin hilfreich, und
um die heutigen Beispiele auszuführen, könnte man sich schon Parrot installieren,
da Rakudo gerade entscheidende Fortschritte erzielt. Informationen dazu hält dies
Seite "www.parrotcode.org" bereit. Wer das scheut, kann aber aber auch weiterhin
Pugs verwenden.

=head2 Noch Operatoren übrig?

Nach "Operatoren für Skalare" und "Operatoren für Arrays" ist sicher "Operatoren
für Hashes" der nächste logische Titel. Nur leider gibt es keine speziellen
Operatoren für Hashes in Perl 6. Außer vielleicht den "dicken Pfeil" ("fat arrow").
Ähnlich dem Komma, daß einen Array erzeugt, weist der "=>" den Interpreter an,
einen Hash zu bilden. Deswegen wird er auch manchmal "hash composer" genannt.

Perl 6:
$ziffern = (7); # Zuweisung eines Wertes
$ziffern = 7,; # Referenz auf einen Array
%ziffern = 1 => 'adin', 2 => 'dwa';
%ziffern = {1 => 'uno', 2 => 'due'}; # geht auch

Da runde Klammern nun nur noch gruppieren und geschweifte Klammern per default
einen anonymen Codeblock darstellen, braucht der Interpreter auch diesen Hinweis
um zu erkennen, daß der Programmierer gerne einen Hash hätte. Weil geschweifte
Klammern darüber hinaus immernoch für Hashreferenzen stehen können, wird in der
letzten Beispielzeile eine solche erzeugt. Nur wird diese, anders als in Perl 5,
automatisch dereferenziert, wenn sie einem Hash zugewiesen wird. Dieses Prinzip
wurde in der letzten Folge schon anhand von Arrays demonstriert. In Perl 5 war der
"fat arrow" nur eine lustige Schreibweise für ein Komma. Es half dem Programmierer
zu erkennen daß hier ein Hash ensteht, aber er hätte genauso gut schreiben können:

Perl 6:
%ziffern = (0, 'null', 1, 'eins');
%ziffern = {1, 'jeden', 2, 'dva'};

Dies funktioniert auch weiterhin wunderbar. Aber nicht weil nun Hashes immer noch
Arrays mit gerader Länge sind, sondern weil es eine Regel gibt, wie der Array in
einen Hash(kontext) umgewandelt wird. Und ja, in der zweiten Zeile liefert ein
anonymer Block einen Array zurück. In diesem Beispiel stört das nicht.Aber es kann
zu sehr unerwarteten Ergebnissen führen, da syntaktisch gleiche Blöcke in
Sonderfällen andere Rückgabewerte haben könnten. Um es eindeutig zu halten,
können die Operatoren C<%> und C<hash> den Hashkontext erzwingen und anzeigen.

Perl 6:
$hashref = hash{ 0, 'null', 1, 'eins' };
$hashref = %( 0, 'null', 1, 'eins' );
# oder klassisch:
$hashref = { '1' => 'a', '2' => 'b', 3 => 'c' };
# entspricht \('1' => 'a', '2' => 'b', 3 => 'c');
# oder auch %( 1..3 Z 'a'..'c' );

Ein Hash kann aber auch in einen anderen Kontext überführt werden. Im boolschen
Kontext meldet er, ob er überhaupt Schlüssel besitzt, im numerischen Kontext
die Anzahl der Schlüssel und im Stringkontext gibt er seinen gesamten Inhalt als
String aus.

Perl 6:
my %buch = ( 1..3 Z 'a'..'c');
? %buch # Bool::True
+ %buch # 3, entspricht %buch.elems
~ %buch # "1\ta\n2\tb\n3\tc\n"

Weit praktischer ist aber meistens die Ausgabe der folgenden, selbsterklärenden
Hashmethoden, welche einen Array zurückgeben.

Perl 6:
%buch.keys; # (1, 2, 3), entspricht keys %buch
%buch.values; # ('a', 'b', 'c'), auch values %buch
%buch.kv; # (1, 'a', 2, 'b', 3, 'c')

C<keys> und C<values> sind altbekannte Perl 5-Befehle, die es selbstverständlich
auch weiterhin gibt. Aus ihren Initialien leitet sich der Name der Methode C<.kv>
ab, die abwechselnd zugehörige Schlüssel und Werte in einem Array aufzählt. Etwas
anders funktioniert dagegen die Methode C<.pairs>. Sie liefert key und value in
einem Skalar, also einen Array von Wertepaaren. Das Gleiche erhält man auch, wenn
ein Hash einem Array zugewiesen wird.

Perl 6:
%buch.pairs; # (1 => 'a'), (2 => 'b'), (3 => 'c')
@buch = %buch; # dito

=head2 Werdet ein Paar

Key und value in einem Skalar? Das mag zuerst nach einem Array oder vielleicht
einer Junction klingen, ist aber einfach ein Wertepaar. Das Paar gehört zu den
völlig neuen Datentypen, die Perl 6 einführt. Eigentlich sind es auch Paare, die
mit dem "fat arrow" erzeugt werden. In den Synopsen wird "=>" desweg oft auch
"pair constructor" genannt.

Perl 6:
my $pair = 'Jakub' => 'Helena';
$pair.isa(Pair) # ergibt Bool::True
$pair.key # 'Jakub'
$pair.value # 'Helena'

Paare können aber auch noch anders generiert werden.

Perl 6:
my $pair = :Jakub('Helena'); # oder kürzer:
my $pair = :Jakub<Helena>; # <> ist das neue qw()

Selbstverständlich funktioniert auch diese Schreibweise für Hashes.

Perl 6:
%regent = :Atreides<Paul>, :Harkonnen<Wladimir>, :Ordo<Executrix>;
$hashref = {pair <Atreides Paul Harkonnen Wladimir Ordo Executrix> };

Allerdings dient das nicht der optischen Vielfalt, sondern zeigt, daß Paare mehr
Aufgaben haben, als Hashbausteine zu sein (obwohl sie dazu sehr geeignet sind).
Ungeordnete Listen von Wertepaaren mit eindeutigen Schlüsseln entsprechen sicher
eher der Idee eines Hashes als Listen mit gerader Länge. Das nächste Beispiel
ist ein bewußt herbeigeführter Unfall, der die Schwäche von Perl 5 demonstriert.
Einzelne Werte die dem Hash entnommen wurden können jede Zugehörigkeit zwischen
den Schlüsseln und Werten zerstören.

Perl 5:
my %h = (1=>2, 3=>4);
%h = grep {$_ % 2} %h;
say %h; # {1 => 3 }

Zum Glück wurde für Perl 6 auch diese Schmuddelecke aufgeräumt.

Perl 6:
%h = grep {$_.value % 2} %h.pairs;

Diese Fassung macht nicht nur mehr Sinn, sondern ist auch noch lesbarer, da hier
explizit steht, was geschieht. Sie kann auch keine unsinnigen Ergebnisse liefern,
da korrekterweise immer Paare durchgereicht werden. Doch um zu beweisen daß die
neue Ordnung nicht einschränkt, hier das Perl 5-Beispiel im Perl 6-Syntax.

Perl 6:
%h = grep {$_ % 2} %h.kv;

=head2 Parameterpaare und $@%

Mit Paaren lassen sich wundersame Datenstrukturen wie Hybride aus Hash und Array
erzeugen oder Paarlisten, in denen Schlüssel mehrfach vorkommen können. Aber die
wichtigste Verwendung von Paaren außerhalb der Hashes sind benannte Parameter.
Diese wurden in Perl 5 oft mithilfe von Hashes simuliert. Jedoch bietet Perl 6
dafür einen expliziten Mechanismus der viele interessante Techniken ermöglicht.
Subroutinen und Parameterübergaben sind aber das Thema der nächsten Folge. Doch
selbst "Kernfunktionen" der Sprache haben benannte Parameter, welche die zweite
Syntax der Paare benutzen. Die in Folge 2 vorgestellten Dateitestoperatoren
C<:r :w :e> sind nichts weiter als Attribute des Objektes vom Typ Filehandle.
Dabei drückt die Formulierung C<:r> aus: "Ich hätte gerne den Wert, der unter dem
Schlüssel "r" gespeichert ist". Ähnliches gilt auch beim Öffnen einer Datei.

Perl 6:
my $fh = open "datei.txt", :r;

Die Datei wird im Lesemodus geöffnet, indem der benannte Parameter "r" gesetzt
wird. In dem Beispiel fällt auch auf, daß Filehandle kein eigener Variablentyp
sind und auch keinen eigenen Namensraum mehr besitzen. Auch Verzeichnishandler
und Formate werden nun in Skalaren gespeichert. Die Formate weichen dazu aus dem
Sprachkern in ein Modul. Auch Token wie C<__LINE__> oder C<__PACKAGE__>, die man
als Systemvariablen mit eigenem, sonderbaren Namensraum ansehen könnte, sind in
ihrer neuen Schreibweise C<$?LINE> und C<$?PACKAGE> eher als Variablen erkennbar.
Ihr seltsamer Namensraum nennt sich nun "compiler hint variables". Er umfasst
Informationen, die ab dem Zeitpunkt der Kompilierung feststehen und auch nicht
geändert werden dürfen. Eine Zuweisung wie C<$?FILE = 'was anderes';> würde einen
Compile-Error ausgeben. Dieser Sonderstatus wird mit der sekundären Sigil (Twigil)
"?" markiert. Achtung: In Perl 6 bezeichnet Token eine sehr einfache Form einer
Regex.

Die Streichung der 4 Sondernamensräume für Variablen (Handler, Formate und Token)
sind weitere Beispiele des Grundsatzes: "keine Ausnahmen" und der Forderung nach
einem deklarativen Syntax, der den Inhalt eines Ausdrucks deutlicher sichtbar macht.
Die verbliebenen Namensräume können eindeutig an der Sigil unterschieden werden.
Oder einfacher: $wunder, @wunder und %wunder sind drei verschiedene Variablen.

=head2 Datentyp Code

Der vierte Namensraum ohne Sigil, ist der der Subroutinen. Und wie bei Hashes und
Arrays, können Referenzen auf Routinen ebenfalls in Skalaren gespeichert werden.

Perl 6:
my $coderef = sub { say "Moin #perl" }

Die besitzen dann den Datentyp "Code". (Das fehlende Semikolon ist kein Fehler.
Perl 6 verlangt nur dann ein solches, wenn mehrere derartiger Deklarationen ohne
den Befehl C<sub> in eine Zeile schreibt. Als Eselsbrücke: ein "}" am Zeilenende
impliziert ein Semikolon.) Das C<sub> könnte man also auch weglassen, was nichts
am Datentyp und an der Benutzung der Variable ändert.

Perl 6:
my $coderef = { say "Moin #perl" }
# dito, ebenfalls noch möglich
my $cr = \{ say "Moin #perl" }
$cr.isa(Code) # ergibt Bool::True
$coderef(); # führt den Block aus

Trotzdem sind die Unterschiede zwischen einer "sub" und einem Block so zahlreich,
daß man damit viele Seiten füllen kann, sie alle aufzuzählen. Deshalb wird diese
Folge auch eher Blöcke behandeln und erst die nächste die Sonderform "Subroutine".
Einfache Blöcke besitzen nämlich nur Grundfähigkeiten und Befehle wie C<while>,
C<if>, C<package> und C<sub> fügen dem weitere Funktionalität hinzu, weswegen sie
im Perl 6-Jargon Blockmodifikatoren genannt werden. Da diese Modifikatoren "builtins"
und keine Routinen sind, kann man sich jetzt nicht nur die runden Klammern sparen.
Es wird empfohlen auf sie zu verzichten. Und wenn nicht anders möglich, sollte man
zumindest darauf achten, zwischen Modifikator und den runden Klammern Leerzeichen
zu lassen, es sei eine C<sub> namens C<if> möchte angesprochen sein.

Perl 6:
if $a > 6 { say "Zu alt für den Kindergarten" }
if($a > 6) { ... } # Error

Doch beginnen wir mit einem nackten Block.

=head2 Closure

Blöcke sind in Perl 6 alles, was von geschweiften Klammern umschlossen ist, soweit
nicht darin ein C<=>> oder C<pair> steht, oder die voranstehenden Operatoren C<%>
oder C<hash> eine Hashreferenz erzwingen. Sie teilen Code in logische Einheiten.
Dadurch werden die Quellen übersichtlicher und verständlicher. Es erlaubt aber
auch Variablen einem Block zuzuordnen. Das hat den großen Vorteil, daß man damit
heimtückische Überschneidungen mit gleichnamigen Variablen anderer Programmteile
ausschließen kann. Außerdem spart es Arbeitsspeicher, wenn die Lebensdauer einer
Variable auf den Block begrenzt wird, in dem ihr Inhalt gebraucht wird.

Der erste Versuch in die Richtung war der Befehl C<local>, der bereits vor Perl 5
eingeführt wurde. Doch der überlagert eine eventuell exisierende, gleichnamige
Variable temporär, bis die Ausführung des aktuellen Blocks beendet ist. Deswegen
wurde die Anweisung in C<temp> umbenannt. Eine echte Bindung zwischen Variable und
Block erzeugt C<my>, welches Perl 5 brachte. Seit dem wird eindringlich empfohlen
C<my> anstatt C<local> zu verwenden. Wenn nämlich aus einem Block (in dem eine
C<local>-Variable definiert wurde) eine Routine aufgerufen wird, überschreibt die
"lokale" Variable dort gleichnamige Brüder. Da das selten den Erwartungen entspricht,
sollte man es mit C<my> oder C<state> verhindern. Eine so erzeugte, lexikalisch
lokale Variable wäre innerhalb der Subroutine unbekannt und wird nur eingeblendet,
während ein Befehl des betreffenden Blocks ausgeführt wird. Einziger Unterschied
zwischen beiden Befehlen: C<my> initialisiert die Variable nach jedem Neustart des
Blocks von neuem mit dem Anfangswert, wohingegen C<state> daß nur beim ersten Mal
tut und sich danach den Inhalt bis zum nächsten Blockaufruf merkt. Dieses Verhalten
von C<state>-Variablen nennt man in der Informatik "Closure" und ist seit Jahren
Bestandteil funktionaler Programmierung. Es ließ sich auch mit einem zusätzlichen,
umschließenden Block und C<my> simulieren, was aber umständlich und fehleranfällig
war. Für einfache Closures wurde deshalb der C<state>-Befehl von Perl 6 nach 5.10
zurückportiert.

=head2 Einfache Ausführung mit Rückhand

In Blöcken stehen meist mehrere Befehle, von denen der zuletzt ausgeführte den
Rückgabewert des Blocks angibt. Um ihn ihn einer Variable zuzuweisen, muß der
Befehl C<do> verwendet werden, auch wenn nackte Blöcke immer ausgeführt werden,
solang sie keine Parameter an eine Routine sind. (wie bei map, sort etc.)

Perl 6:
my $zahl = do { rette_regenwald(); glückszahl() }
# oder länger :
my $coderef = { rette_regenwald(); glückszahl() }
my $zahl = $coderef();

Auch auf einzelne Befehle, die nicht von geschweiften Klammern umgeben sind, kann
C<do> angewendet werden, um sie als Ausdruck zu evaluieren. Daher ist auch diese
umständliche Umschreibung des ternären Operators möglich.

Perl 6:
$x = do if $a { $b } else { $c };
$x = $a ?? $b :: $c; # kürzer

Da C<do> einen Block immer genau einmal ausführen läßt, werden solche Abschnitte
jetzt auch "do once loop" genannt. Um mit dieser einfachen Regel nicht zu brechen,
wurden Schleifenkonstrukte wie C<do { ... } while ()> in C<repeat { ... } while ()>
umbenannt. Auch alle weiteren Verwendungsmöglichkeiten von C<do> die Perl 5 kennt,
wurden gestrichen. Dafür führte Larry mit C<gather> eine Variante von C<do> ein,
die einem Block erlaubt eine Liste zurückzugeben. Die einzelnen Werte werden mit
dem Befehl C<take> einzeln oder in Gruppen ausgewählt.

Perl 6:
# enthält: 'Gauguin', 'Cezanne'
my @maler = gather {
my $r = take 'Gauguin';
# $r enthält 'Gauguin'
take 'Cezanne' if $r;
}
# enthält: 1,10,2,20
my @x = gather for 1..2 {
take $, $ * 10;
}

In Kombination mit Schleifen und bedingten Anweisungen entfaltet C<gather/take>
erst seine volle Mächtigkeit. Die Beispiele zeigen auch wie Blockmodifikatoren
ohne weitere Klammern kombiniert werden können, was eine Konsequenz der bereits
vorgestellten Regeln ist. Auch bei nachgestellten Konstrukten kann damit manche
Zeilen vereinfacht werden.

Perl 5:
{ print if $_ % 2 } for 0..10;

Perl 6:
.print if $_ % 2 for ^11;

Soll in Perl 6 ein Befehl (als Methode) auf $_ angewendet werden, sollte er mit
einem Punkt beginnen. Die genauen Hintergründe dieser Designentscheidung wurden
in der ersten Folge erläutert. Doch zurück zu den Rückgabewerten. So wie C<take>
sie für den umgebenden C<gather>-Block bestimmt, gibt es auch einen Befehl für
den skalaren Rückgabewert, der gleichzeitig die Ausführung des Blocks abbricht.
Dieser Befehl heißt zur allgemeinen Überraschung nicht C<return>. C<return> ist
Subroutinen und artverwandten Funktionseinheiten vorbehalten, aus Gründen, die
in der nächsten Folge genau beschrieben werden. Das schlichte Verlassen des
umschließenden Blocks wird von einem C<leave> ausgeführt. Soll ein bestimmter
Block beendet werden, so muß dessen Anfang durch ein "Label" (LABELNAME:)
markiert sein, um mit C<LABELNAME.leave> aus ihm hinauszutreten. Daraus folgt
ebenfalls, daß Perl 6 die mittelalterlichen Freuden extensiver C<goto>-Benutzung
keineswegs einschränkt. Selbst ein fortraneskes "computed goto" kann unverändert
(wie in Perl 5) geschrieben werden.

Der mit C<leave> definierte Rückgabewert kann aber noch mehr, als in eine Variable
zugwiesen zu werden. Er kann auch die Ausführung von Blöcken steuern, die mit
Auswahloperatoren verknüpft sind.

Perl 6:
tu_was() && das_auch();
# ist andere Schreibweise für:
{ tuwas() } && { das_auch() };
# ist andere Schreibweise für:
{ tuwas() } and { das_auch() };

Doch C<&&>, C<||> und C<^^> wurden schon in Folge 2 behandelt und für die Ops
macht es keinen Unterschied ob sie die Ergebnisse von einzelnen Befehlen oder
ganzen Blöcken verknüpfen. Wirklich neu und speziell nur für Blöcke sind hingegegen
C<andthen> und C<orelse>. Grundlegend entsprechen sie den Befehlen C<and> und C<or>.
Beendet der linke Block erfolgreich, läßt C<andthen> ebenfalls den rechten
ausführen. Allerdings, um die Kontextvariable C<$_> weiterhin benutzen zu können.
Sie wird in diesem Sonderfall sozusagen "Closure" zweier Blöcke. C<orelse> eignet
sich vor allem zur Fehlerbehandlung. Ist der linke Rückgabewert nicht positiv,
startet C<orelse> den rechten Block, in dem die Fehlermeldung (Sondervariable $!)
weiterhin bekannt ist.

=head2 Bedingte Ausführung ist einfach

In der Regel werden jedoch bedingte Anweisungen mit den vertrauten Schlüßelwörtern
C<if>, C<elsif>, C<else> und C<unless> formuliert. Letzeres ist zwar eine Eigenheit
von Perl, die nicht mehr mit C<elsif> und C<else> kombiniert werden darf, aber die
Funktionsweise dieser 4 Befehle sollte keiner weiteren Erklärung bedürfen.
Auch C<given>, C<when> und C<default> wurden mit ihrer Einfürung zur Version
5.10 genügend vorgestellt. Vergessen wurde dabei manchmal lediglich, daß C<given> und
C<when> sich auch in anderen Zusammenhängen benutzen lassen. C<given> eignet sich
hervorragend umständliche Ausdrücke zu vereinfachen wie folgende:

Perl 6:
$tiefer.objekt.namensraum.var1 =
$tiefer.objekt.namensraum.var2 +
$tiefer.objekt.namensraum.var3;
# oder :
given $tiefer.objekt.namensraum
{ $.var1 = $.var2 + $_.var3 }

Da C<given> ebenso wie C<for> (es gibt kein C<foreach> mehr) die Kontextvariable
setzt, können C<when>-Klauseln auch in C<for>-Schleifen verwendet werden.

Perl 6:
for @beine {
print "Ist $_ "
when 1 { say "überhaupt ein Tier?" }
when 6|8|10 { say "ein Insekt?" }
when > 20 { say "eine Raupe?" }
default { say "ein Zweibein"}
}

C<default> ist nur ein Alias auf C<when *> (oder $_ ~~ Whatever) und im Gegensatz
zu einem "C-switch" entfällt auch das notorische C<break>, da ein implizites
C<break> jede C<when>-Klausel beendet. Wer mag kann aber auch jederzeit mit C<break>
die Klausel und den umgebenden "contextualizer"-Block manuell verlassen. Wenn nur
zur nächsten Klausel gesprungen werden soll, dann ist C<continue> das Mittel der Wahl.
Noch weitere besondere Sprungbefehle gibt es für Schleifen.

=head2 Schöne Schleifen

Auch hier wurden die alten Standarts kaum angerührt. C<while> und C<until> blieben
unverändert, lediglich ein C<repeat { ... } while $a < 3;> ist gewöhnungsbedürftig.
Ansonst wird der Ausdruck nach C<while> und C<until> (ebenso wie bei C<if> und C<unless>)
in den boolschen Skalarkontext evaluiert. Selbstverständlich wird dann bei einem
Ergebnis von Bool::True (beziehungsweise Boole::False) der Block ausgeführt. <for>
ist jetzt ein reiner Array-Iterator und evaluiert entsprechend in den "lazy list"-Kontext.
Genau deshalb wird die zeilenweise Abarbeitung einer Datei jetzt so geschrieben:

Perl 6:
my $fh = open "aufsatz.txt";
for =$fh {
...

Würde jemand C<while> anstatt C<for> nehmen, so lieferte C<=$fh> im Skalarkontext den
gesamten Dateiinhalt auf einmal ab. Bis dahin ist alles logisch, doch was geschah mit
der klassischen "C-Stil"-for-Schleife. Ihr Ausdruck wird eindeutig in den void-Kontext
evaluiert und deshalb bekam sie ein eigenes Schlüsslwort. Inhaltlich unterschiedliches
soll auch optisch unterscheidbar sein. Deswegen heißt die Allzweckschleife nun "Schleife"
(C<loop>). Da der leere Kontext immer das Selbe Ergebnis liefert, ist auch C<loop {...}>
(ein Synonym für C<loop (;;) {...}>) eine nettere Schreibweise für C<while 1 {...}>, daß
weiterhin möglich ist. Eine weitere gute Nachricht: die Sprungbefehle C<last> (verlasse
die Schleife), C<redo> (wiederhole den Durchgang) und C<next> (zur nächsten Iteration)
funktionieren jetzt einwandfrei. Bei C<do {...} while ();> hat hier Perl 5 immer noch
Probleme, denn das sind nachträglich eingeführte Konstrukte und keine echten Schleifen.
Wie C<leave> können auch diese Sprungbefehle mit Labelmarken wie z.B. C<LABEL.next;>
oder C<next LABEL;> kombiniert werden.

=head2 Blockparameter

Im letzten Beispiel fehlte noch ein entscheidendes Detail. Für C<for>-Schleifen wird
oft eine lokale Laufvariable definiert:

Perl 5:
for my $i (1..10) { ...

Weil hier das C<my> nicht innerhalb des Blockes steht, für daß es seine Gültigkeit
besitzt, würde das gegen die klaren Regeln in Perl 6 verstoßen. Deshalb gibt es dafür
nun einen besonderen Syntax der es gleichzeitig zuläßt mehrere Parameter an einen
Block zu übergeben. Da der Syntax symbolisieren soll, daß hier schnell ein paar Werte
in den Block "hineingeworfen" werden, nennt sich diese Formulierung "pointy block".
Sie erlaubt elegante Lösungen, für die bisher wesentlich kompliziertere Formulierungen
notwendig waren.

Perl 6:
for 1..10 > $i { ...
for %h.kv
> $k, $v { ...
for @a Z @b Z @c > $a, $b, $c { ...
while berechne()
> $wert { ...

Auch wenn C<while> in den boolschen Kontext evaluiert, bekommt C<$wert> den Betrag
den C<berechne()> liefert. Wie beschrieben sind diese Variablen Parameter und nicht
lexikalisch lokal und können daher auch nicht innerhalb des Blocks verändert werden.
Braucht man jedoch unbedingt veränderbare Laufvariablen, so muß dies mit einem leicht
geänderten Syntax gekennzeichnet sein.

Perl 6:
for 1..10 <-> $i { ...

Wenn kein Variablennamen angegeben wäre, landen die Inhalte natürlich in $_ oder @.
Nun ist @2 nicht immer der schönste Variablennamen und verwirrt manch einen Neuling.
Für solche Fälle erfand Larry die automatisch benannten Parameter die auch einen
weiteren Sonderfall in Perl 5 mit einer allgemeinen Regel abschaffen. Damit ist der
C<sort>-Befehl gemeint, in dessen Block die einmaligen Sondervariablen $a und $b
bekannt sind, welche jetzt C<$^a> und C<$^b> geschrieben werden. Die Twigil (sekundäre
Sigil) "^" kennzeichnet die Platzhalter-Variablen. Diese dürfen benutzt werden,
ohne ihre Namen zu deklarieren. Man muß nur darauf achten, daß alphabetisch sortiert,
ihre Namen der Reihenfolge der Parameter entsprechen, in der sie dem Block übergeben
wurden.

Perl 6:
for 1..10 { say $^i ...
for 1..10 { say $^cc ...
$coderef1 = { say $^a, $^b };
$coderef2 = { say $^z, $^zz };
$coderef1('a','d'); # sagt ade
$coderef2('a','d'); # dito

Mehr dazu in Teil 5, wenn in Subroutinen die hohe Schule der Parameterübergabe
zelebriert wird.


Upload Files

Click "Browse" to find the file you want to upload. When you click "Upload file" your file will be uploaded and added to the list of attachments for this page.

Maximum file size: 50MB

 
 
 
File Name Author Date Uploaded Size

Save Page As

Enter a meaningful and distinctive title for your page.

Page Title:

Tip: You'll be able to find this page later by using the title you choose.

Page Already Exists

There is already a page named XXX. Would you like to:

Save with a different name:

Save the page with the name "XXX"

Append your text to the bottom of the existing page named: "XXX"

Upload Files

Click "Browse" to find the file you want to upload. When you click "Add file" this file will be added to the list of attachments for this page, and uploaded when you save the page.

 
 
 
Add Tags

Enter a tag and click "Add tag". The tag will be saved when you save the page.

Tag: 

Suggestions: