© Dmitry Kalinovsky, 123RF

Perl 6 beschert der Perl-5-Syntax einen neuen Anstrich und führt ein richtiges Objektsystem ein. Ein Praxistest anhand der Re-Implemtierung eines alten Blackjack-Spiels.

Totgesagte leben länger, heißt es, und das jahrzehntelang herbeigelechzte Perl 6 scheint nun tatsächlich Gestalt anzunehmen. Das erfuhr ich kürzlich in Orlando im Bundesstaat Florida, als ich Gelegenheit hatte, der Grassroots-Perl-Konferenz YAPC 2016 beizuwohnen. Etwa zwei Drittel der Vorträge widmeten sich Perl-5-Themen, aber zu meinem Erstaunen wenden sich nun mehr und mehr Leute in der Community allen Ernstes dem Nachfolger und jahrelangen Sorgenkind Perl 6 zu.

Schon vor sage und schreibe elf Jahren, auf der Oscon-Konferenz 2005 hatte Damian Conway vollmundig angekündigt, das “Endgame” der Entwicklung sei angebrochen, aber was dann folgte, waren mehrere Rückschläge und Neuanfänge. Bis Ende letzten Jahres dann endlich die virtuelle Maschine Rakudo betriebsfähig war, die zwar nicht mit Performance punktet, aber doch zuverlässig Perl-6-Code durchrattert.

Was ist Perl 6?

Um Perl 6 kennenzulernen, ist es hilfreich, zu analysieren, was Perl 5 gefehlt hat. Manko Nummer eins ist ohne Zweifel ein fest eingebautes Objektsystem. In Perl 5 war es notdürftig aufgenietet, aber niemand, der einigermaßen bei Verstand ist, hätte auch nur in einem mittelgroßen Programm die zu Klassen gestempelten Hashstrukturen oder als Hashelemente eingebaute Attribute verwendet.

Vielmehr haben professionelle Perl-Entwickler seit bestimmt zehn Jahren das CPAN-Modul Moose oder einen seiner Ableger genutzt, um Klassen zu definieren und auf deren Attribute zuzugreifen. Das befreit Entwickler nicht nur von der Fronarbeit, lästigen Boilerplate-Code einzutippen, sondern spannt auch ein Sicherheitsnetz auf, denn der Compiler merkt sofort, falls sich ein Tippfehler eingeschlichen hat. Bei einem falschen Hashkey ist das nicht der Fall und fatale Fehler kommen erst zur Laufzeit und unter Umständen nach langer Betriebszeit aus ihren Löchern. Eigentlich eine Selbstverständlichkeit für jede moderne Sprache, aber eben in Perl 5 historisch bedingt leider nur als Flickwerk implementiert.

Geräuschvoller Code

Die Macher Larry Wall und Damian Conway spendierten Perl 6 also Syntax zur Definition von Klassen und zum Aufrufen von Objektmethoden, denen Entwickler Listen mit benannten Parametern übergeben können. Nebenbei sind auch einige logische Ungereimtheiten in der Perl-5-Syntax bereinigt, die sich als Fallstricke für Anfänger erwiesen hatten.

Und weil man schon mal dabei war, kommt noch hier und da geklaute Syntax aus allen möglichen moderneren Sprachen wie Python oder Ruby hinzu, die irgendwie praktischen Nutzen verspricht und clevere Tricks beim Programmieren verheißt. Herausgekommen ist eine Sprache mit relativ vielen Sonderzeichen, die die Kompatibilität zum alten Perl 5 komplett zerbricht und einen neuen Interpreter namens Rakudo braucht.

Schrödingers Katze

Eines der etwas clever-exotischen neuen Konstrukte in Perl 6 sind die so genannten Superpositionen aus der Feder von Damian Conway. Letzterer ging mit der Idee schon vor 13 Jahren auf Konferenzen hausieren und führte sie später in einem CPAN-Modul namens Quantum::Superpositions als Quanten-Variablen in die Sprache ein.

Wie die quantenmechanische Katze in Schrödingers Experiment [2], die gleichzeitig tot und lebendig ist, nehmen diese Variablen mehrere Werte gleichzeitig an. So kann ein Integer zugleich 1 und 2 sein, und addiert man 5 dazu, ist das Ergebnis 6 und 7. Damals fiel mir dazu als Beispiel das Casino-Spiel Blackjack ein, bei dem ein Ass entweder 1 oder 11 Augen zählt.

Blackjack in Perl 6

2003 schrieb ich im Linux-Magazin [3] eine Kolumne mit einem Skript, das ein Blackjack-Spiel simuliert. Also überlegte ich mir, als Test das Blackjack-Programm in modernem Perl 6 nachzuimplementieren. Listing 1 zeigt, wie Perl 6 den Klassen-Code für eine Blackjack-Karte implementiert. Kartenwerte heißen auf Englisch “Rank”, also hat die Klasse »Blackjack::Card« im Listing ein Attribut namens »rank« mit dem Defaulttyp eines Perl-Skalars, der einen String oder Integer beherbergen darf. Wer in Perl 5 mit dem Moose-Modul gearbeitet hat, braucht sich mit Perl 6 nicht groß umzustellen, die neue Syntax ist fast identisch.

01 use v6;
02 use strict;
03 use Terminal::ANSIColor;
04
05 class Blackjack::Card {
06   has $.rank;
07   has $.suit;
08   has $.val;
09   has $.suit_color;
10
11   method Str() {
12     return colored(
13       "{self.rank}", self.suit_color );
14   }
15 }

Neben einer Farbe (»suit« ) verfügt jede Spielkarte noch über einen Zählwert (»val« ) und die Darstellungsfarbe auf dem Bildschirm »suit_color« . Die Definitionen in Listing 1 beginnen mit einem Dollarzeichen, das die zugehörigen Attribute als Perl-Skalare auszeichnet. Alternativ bietet Perl 6 für Attribute auch Arrays (@) und Hashes (%) sowie beliebige Klassennamen für Objektattribute. Der nach den “Sigils” genannten Sonderzeichen folgende Punkt zeichnet eine Variable als Objektattribut aus.

Perl 6 definiert dazu gleich hinter den Kulissen praktische Methoden für den lesenden und schreibenden Zugriff (etwa »obj.rank(“A” )« ) sowie benannte Parameterlisten für den Konstruktor, der dann Aufrufe wie »Blackjack::Card.new( rank => “A” )« versteht. Wichtig: Perl 6 ersetzt den Pfeil »->« durch einen Punkt, aus »$o->foo()« in Perl 5 wird »$o.foo()« in Perl 6. Um innerhalb eines Objekts auf das Objekt selbst zuzugreifen, dient das Schlüsselwort »self« (ohne Sigil).

Strings in Perl 6 können nicht nur automatisch interpolierte Variablen wie in »”Hallo $gast”« enthalten, sondern auch dynamisch ausgeführte Codekonstrukte in geschweiften Klammern, was besonders mit der neuen Objektsyntax hilft, falls der Wert nicht in einer Variablen steckt, sondern aus einer Methode stammt: »”Hallo {$o.gast()}”« ersetzt die geschweiften Klammern und alles dazwischen mit dem Rückgabewert der Methode »gast()« auf ein in »$o« liegendes Objekt.

Grundkurs Blackjack

Wie funktioniert Blackjack in einem Casino in Las Vegas? An einem Kartentisch steht ein Kartenausgeber (der Dealer) den Spielern gegenüber und zieht aus einem so genannten Schuh einzeln Karten von einem 52-blättrigen Pokerblatt (Abbildung 1). Um den Kartenzählern unter den Spielern im Casino die Arbeit zu erschweren, enthält ein Kartenschuh gut gemischt bis zu acht Kartenspiele mit 52 Karten. Zuerst gibt der Dealer jedem Spieler am Tisch zwei offene Karten, anschließend gibt er sich selbst eine offene und eine verdeckte Karte.

Abbildung 1: Der Blackjack-Dealer hat sich eine offene Karte und jedem der sechs Spieler am Tisch jeweils zwei Karten zugeteilt.

Dann sind die Spieler an der Reihe, sie können entweder weitere Karten vom Dealer verlangen (“Hit”) oder dankend ablehnen (“Stand”). Ziel des Spiels ist es, mit allen gezogenen Karten möglichst nahe an die Gesamtpunktzahl 21 zu kommen, ohne diese zu überschreiten, denn sonst verliert der Spieler automatisch. Sind die Spieler befriedigt, fängt der Dealer an, seine verdeckte Karte offenzulegen und eventuell für sich selbst weitere Karten aus dem Schuh zu ziehen.

Soft und Hard 17

In Las Vegas spielt der Dealer wie ein Roboter nach einem festen System: Er zieht neue Karten, bis er mindestens 17 Punkte hat. Kommt zum Beispiel eine Zehn aus dem Schuber und hinterher eine Sechs, zieht er noch mal, auch wenn’s dann meist rappelt und er mit einer 10-wertigen Karte über das Ziel von 21 hinausschießt und verliert, obwohl sein Gegenspieler zum Beispiel bereits bei 13 aufgehört hat zu ziehen.

Diese Regel ist bei Casinos identisch, mit einer kleinen Variation, der so genannten “Soft 17” [4]. Diese Regel bestimmt, ob der Dealer auch bei einer 17, die sich aus mindestens einem Ass zusammensetzt, noch mal ziehen muss. Zieht der Dealer zum Beispiel ein Ass und eine Sechs, hat er 17 und zieht nach der “Hard 17”-Regel nicht mehr. Schreibt das Casino “Soft 17” vor, muss er nochmals ziehen, weil seine 17 (wenn das Ass nicht als 11, sondern als 1 zählt) auch als 1 + 6 = 7 interpretierbar ist. Das gibt dem Dealer statistisch einen kleinen Vorteil, seine Gewinnchancen wachsen um 0,2 Prozent.

Blackjack im Terminal

In der Kommandozeilenversion des nachfolgend vorgestellten Skripts »blackjack.p6« folgt der Dealer der “Soft 17”-Regel und tritt gegen einen Spieler an. Abbildung 2 zeigt einen Durchgang, bei dem der Spieler gewinnt. Zuerst zieht der Dealer eine Dame (»Q« für Queen) und eine verdeckte Karte, die das Skript nicht anzeigt. Der Spieler erhält zwei Zweien und tippt »h« (“Hit”), um Karten zu verlangen. Es kommt ein Ass (»A« ) nach, und nachdem ein Ass im Blackjack entweder 1 oder 11 zählt, ist der Wert der Kartenhand nun 5 oder 15, was das Skript mit »any(5,15)« anzeigt.

Abbildung 2: Das Blackjack-Spiel in Aktion: Hier gewinnt der Casino-Spieler gegen den Dealer.

Ein erneuter Hit bringt eine Zehn, also zählt die Kartenhand entweder 15 oder 25, wobei Letzteres unter den Tisch fällt, weil es 21 übersteigt. Wagemutig drückt der Spieler ein weiters Mal auf »h« , erhält wie durch ein Wunder eine Sechs und hat nun genau 21, die alternative 31 fällt unter den Tisch. Der Spieler drückt »s« (“Stand”) und der Dealer ist dran. Er dreht seine verdeckte Karte um (eine Vier), sodass er nun »Q-4« hält, also eine Dame und eine Vier, die zusammen 14 zählen. Das ist weniger als 17, also zieht er gemäß den Casino-Vorschriften eine weitere Karte, bekommt aber einen Buben (»J« ) und ist nun mit 27 über das Ziel hinausgeschossen und verliert. Der Spieler erhält den Punkt (»Score: 1« ) und seine Gesamtpunktzahl (»Total« ) ist nun 1, da es sein erstes Spiel war.

Karte im Pokerblatt

Die Spielkarten in einem 52-Karten-Blatt repräsentiert ein Objekt der Klasse Blackjack::Deck in Listing 2. Damit der Perl-Parser weiß, dass Perl-6-Code vorliegt und nicht an der neuen Syntax scheitert, gibt »use v6« am Datei-Anfang die Version in einer Syntax vor, die auch der Perl-5-Interpreter versteht und mit einer Fehlermeldung abbricht, sollte jemand ihn versehentlich darauf ansetzen. Zeile 7 definiert mit dem Ausdruck

flat < A J Q K >, 2..10

eine Liste möglicher Kartenwerte (Ass, Zehn, Bube, Dame, König) sowie die Zahlenwerte von 2 bis einschließlich 10.

Durch Leerzeichen getrennte Werte in eckigen Klammern sind die Perl-6-Syntax für die »qw(…)« -Listen in Perl 5. Den Range-Operator »..« gab es in Perl 5 auch, nur münden Konstrukte wie oben nicht wie in Perl 5 in einer langen Liste von Werten, sondern in Listen von Listen, sodass der Ausdruck den zusätzlichen Operator »flat« braucht, um das Ganze zu einer langen Liste auszuflachen.

01 use v6;
02 use strict;
03 use Blackjack::Card;
04
05 class Blackjack::Deck {
06   has @.ranks =
07     [ flat < A J Q K >, 2..10 ];
08   has @.suits =
09     < Hearts Spades Diamonds Clubs >;
10   has %.suit_color =
11     flat self.suits Z
12     flat < red black magenta blue >;
13   has @.cards;
14
15   method shuffle() {
16     for self.ranks -> $rank {
17
18       my $val = 10;
19       if $rank ~~ /\d+/ {
20         $val = $rank.Int();
21       } elsif $rank eq "A" {
22         $val = 1|11;
23       }
24
25       for self.suits -> $suit {
26         self.cards.push(
27           Blackjack::Card.new(:$rank,
28               :$suit, :$val,
29               suit_color =>
30               self.suit_color{ $suit } ));
31       }
32     }
33     self.cards = self.cards.pick( * );
34   }
35
36   method pick() {
37     if self.cards.elems == 0 {
38        self.shuffle;
39     }
40     return self.cards.shift;
41   }
42 }

Um alle Karten zu simulieren, geht die Methode »shuffle()« ab Zeile 15 in Listing 2 mit zwei For-Schleifen durch die Attribute »@.ranks« und »@.suits« , kombiniert jeweils zwei Einträge zu einer Karte der Klasse Blackjack::Card und schiebt das so neu gewonnene Objekt auf den Array »@.cards« . Die Zeilen 18 bis 23 bestimmen den Zählwert jeder Karte, der Eintrag »1|11« für ein Ass ist eine der vorher besprochenen Superpositionen aus den Werten 1 und 11.

Reißverschlussverfahren

Welche Bildschirmfarbe der Hash »%.suit_ color« den Kartenfarben zuordnet, bestimmt sich aus der Verknüpfung von »@.suits« und einer ausgeflachten Liste von Bildschirmfarben in Zeile 12. Der Operator »Z« in Zeile 11 wendet auf die beiden Listen das Reißverschlussverfahren an (“Z” nach dem englischen Wort für Reißverschluss: Zipper) und weist jeder Kartenfarbe im Hash eine Bildschirmfarbe zu. Die For-Schleifen in Perl 6 unterscheiden sich syntaktisch von Schleifen in Perl 5, auf das Schlüsselwort »for« folgt zunächst eine Liste oder ein Array, danach ein Pfeil-Operator und dann der Name der Variablen, die den aktuellen Iterationswert annimmt.

Um das Kartenspiel zu mischen, wendet Zeile 33 einen cleveren Trick mit dem so genannten Whatever-Operator »*« an: Die Methode »pick()« auf einen Array wählt ein willkürliches Element aus, entfernt es aus dem Array und gibt es zurück. Der Whatever-Operator weist Perl 6 an immer weiterzumachen, bis der Array leer ist, und mischt so den ursprünglichen Array durch, gibt ihn als Liste zurück, und die Variable auf der linken Seite der Gleichung erhält die Werte zugewiesen. Die ab Zeile 36 definierte Methode gleichen Namens entfernt eine Karte aus dem gemischten Kartenstapel und gibt sie dem Aufrufer zurück.

Punkten mit Quanten

Alle Karten, die ein Spieler gerade hält, nennt man auf Englisch eine “Hand”, darum implementiert Listing 3 die Klasse Blackjack::Hand. Die Methode »draw()« ab Zeile 9 nimmt ein Objekt vom Typ Blackjack::Card entgegen und fügt es zum Blatt des Spielers hinzu. Um den Zählwert (oder besser gesagt die überlagerten Zählwerte) des Blattes zu ermitteln, addiert die Methode »values()« ab Zeile 20 die Zählwerte aller Karten. Der kritische Wert von 21 ist überschritten, falls keiner der überlagerten Zustände 21 oder weniger anzeigt, und die Methode »is_busted()« ab Zeile 28 gibt in diesem Fall einen wahren Wert zurück (Englisch “busted” für “kaputt”).

01 use v6;
02 use strict;
03 use Blackjack::Card;
04
05 class Blackjack::Hand {
06   has @.cards;
07   has $.name;
08
09   method draw( Blackjack::Card $card ) {
10     push self.cards, $card;
11   }
12
13   method highval() {
14     my $vals =
15       grep { $_ <= 21 }, self.values;
16     return "BUSTED" if !$vals;
17     return $vals;
18   }
19
20   method values() {
21     my $total = 0;
22     for self.cards -> $card {
23       $total += $card.val;
24     }
25     return $total;
26   }
27
28   method is_busted() {
29     return !( self.values <= 21 );
30   }
31
32   method Str() {
33     my $str = "";
34     for self.cards -> $card {
35       $str ~= "-" if $str.chars;
36       $str ~= "$card";
37     }
38     return "{self.name}: " ~
39       "$str ({self.highval})";
40   }
41
42   method is_blackjack() {
43     return self.cards.elems == 2 &&
44     self.values == 21;
45   }
46
47   method score( Blackjack::Hand $other ) {
48     return -1   if self.is_busted;
49     return  1   if $other.is_busted;
50     return  0   if self.is_blackjack and
51       $other.is_blackjack;
52     return  1.5 if self.is_blackjack;
53     return -1   if $other.is_blackjack;
54     self.highval > $other.highval ??
55         return 1 !!
56         return 0;
57   }
58 }

Um das Blatt eines Spielers anzuzeigen, soll es genügen, ein Objekt der Klasse Blackjack::Hand in einen Stringkontext (also innerhalb doppelter Anführungszeichen) zu stellen. Das veranlasst Perl 6 dazu, die Methode »Str()« des Objekts aufzurufen und deren Rückgabewert einzusetzen. Die Funktion ab Zeile 32 von Listing 3 iteriert dazu mit der Methode »cards()« durch alle Karten des Spielerblatts, stellt deren Objekte in Zeile 36 in einen String-Kontext und verbindet die Ergebnisse durch Gedankenstriche.

Der ab Zeile 38 zurückgereichte String enthält den Namen des Spielers, die Karten des Blattes sowie die mittels »highval()« ermittelten Spielwerte. Der Operator zum Verknüpfen von zwei Strings hat sich von einem Punkt (».« ) in Perl 5 zu einer Tilde (»~« ) in Perl 6 geändert. Folglich nutzt Zeile 39 »~=« , um den rechts stehenden String an den links stehenden anzuhängen.

Jackpot mit Blackjack

Hält ein Spieler eine 10-wertige Karte zusammen mit einem Ass, zählt dies als so genannter Blackjack. Falls der Dealer nicht auch mit einer solchen Kombination aufwartet, erhält der Spieler das 1,5-Fache seines Einsatzes als Gewinn ausgezahlt. Die Methode »is_blackjack()« prüft diese Kombination ab Zeile 42, indem sie sicherstellt, dass das Blatt genau aus zwei Karten besteht und einer der überlagerten Zustände genau 21 Augen zählt.

Die dem Spieler zustehenden Gewinnpunkte ermittelt die Methode »score()« ab Zeile 47, die als Argument das Objekt des Dealerblattes zum Vergleich erwartet. Sie gibt »-1« zurück, falls der Spieler einen “Bust” verursacht hat, egal welche Augenzahl der Dealer hat. “Busted” der Dealer, kommt »1« zurück und der Spieler ist einen Punkt im Plus. Haben beide einen Blackjack, ist das Ergebnis unentschieden und es kommt » « zurück. Zu beachten ist, dass der Ternary Operator in Perl 5, der mit »[…]?[…]:[…]« – abhängig vom Test – den ersten oder zweiten Ausdruck zurückgibt, in Perl 6 zu »[…]??[…]!![…]« wird.

Kommandozeilen-Casino

Das steuernde Perl-Skript des Kommandozeilen-Casinos »blackjack.p6« steht in Listing 4 und enthält in seiner ersten Zeile einen Verweis auf den ausführenden Perl-6-Interpreter. Doch wo Perl 6 installieren? Auf http://perl6.org findet sich ein Tarball, den der abenteuerlustige Admin selbst kompiliert, während Hunderte von Warnungen über den Bildschirm flitzen. Am einfachsten holt der moderne Linux-Enthusiast sich aber mittels »docker pull rakudo-star« ein Docker-Image mit installiertem Perl-6-Rakudo.

01 #!/usr/bin/env perl6-in-docker.sh
02
03 use v6;
04 use lib '/perl6';
05 use Blackjack::Card;
06 use Blackjack::Hand;
07 use Blackjack::Deck;
08
09 my $TTY   = open("/dev/tty");
10 my $deck  = Blackjack::Deck.new;
11 my $total = 0;
12
13 while ( 1 ) {
14   my $dealer =
15    Blackjack::Hand.new( name => "Dealer" );
16   my $player =
17    Blackjack::Hand.new( name => "Player" );
18
19   $player.draw( $deck.pick );
20   $player.draw( $deck.pick );
21
22   $dealer.draw( $deck.pick );
23   say "$dealer";
24   $dealer.draw( $deck.pick );
25
26   while !$player.is_busted {
27     say "$player";
28     my $in =
29       prompt-char("Your move (h/s/q):");
30     say "";
31     given ( $in ) {
32       when 'q' { exit( 0 ); }
33       when 's' { last; }
34       when 'h' {
35         $player.draw( $deck.pick ); }
36     }
37   }
38
39   while !$player.is_busted and
40         !$dealer.is_busted and
41         $dealer.values < 17 {
42     say "$dealer";
43     $dealer.draw( $deck.pick );
44   }
45
46   say "$player";
47   say "$dealer";
48
49   my $score = $player.score( $dealer );
50   $total += $score;
51
52   say "Score: $score";
53   say "Total: $total\n\n";
54 }
55
56 sub prompt-char($prompt) {
57   ENTER shell "stty raw -echo min 1";
58   LEAVE shell "stty sane";
59
60   print $prompt;
61   my $in = $TTY.read(1).decode;
62   say "\r";
63   return $in;
64 }

Um ein auf dem Host liegendes Perl- 6-Skript im Perl-6-Interpreter innerhalb des Docker-Containers aufzurufen, stellt Listing 4 in seine erste, die so genannte Shebang-Zeile, den Pfad zum Shellskript in Listing 5. Dies startet den Docker-Container, definiert einen Mount auf das aktuelle Verzeichnis auf dem Host, das daraufhin innerhalb des Containers unter »/perl6« sichtbar ist. Listing 4 fügt deswegen in Zeile 4 einen zusätzlichen Suchpfad für Module als »use lib ‘/perl6’« ein, damit es die Blackjack-Module in den anderen Listings auch findet.

1 #!/bin/sh
2
3 sudo docker run -v `pwd`:/perl6 -i \
4   -t ready /usr/bin/perl6 /perl6/$*

Da der Linux-Kernel aus Sicherheitsgründen keine Shellskripte als Shebang-Programme zulässt, nutzt Listing 4 den Helfer »/usr/bin/env« als ausführendes Programm, um das Shellskript aufzurufen, das akzeptiert der Linux-Kernel.

Spielmodus

Tastatureingaben von der Kommandozeile erfordern es normalerweise, dass der User jede Eingabe mit der Return-Taste abschließt, aber im Spielmodus soll das Blackjack-Skript direkt auf Tastendrücke reagieren. Dazu dient auf Unix-Systemen der Terminal-Modus Raw, den man allerdings nur während der eigentlichen Eingabe aktivieren sollte, um ihn sofort danach in den normalen Cooked-Modus zurückzusetzen, sonst reagiert das Terminal nicht mehr ordnungsgemäß auf später nach Programmschluss eingetippte Shellkommandos.

Deshalb setzt die ab Zeile 56 definierte Funktion »prompt-char()« (Perl 6 erlaubt Gedankenstriche in Funktionsnamen) beim Eintritt ein Shellkommando mittels der Utility »stty« ab, um den Raw-Modus einzuschalten und ihn beim Verlassen der Routine wieder zu deaktivieren. Perl 6 bietet die Schlüsselwörter »ENTER« und »LEAVE« , um Aktionen beim Eintreten und beim Verlassen einer Funktion auszuführen. Vom vorher geöffneten Terminal in der Variablen »$TTY« liest »read(1)« in »prompt-char()« ein Byte, die nachgeschaltete Methode »decode()« macht aus dem eingelesenen Buffer-Byte ein Ascii-Zeichen, das das Skript später mit einem Buchstaben wie “h” (Hit) oder “s” (Stand) vergleichen kann.

Perl 6 verfügt über ein Switch-Statement, das Given/when heißt und ab Zeile 31 zum Einsatz kommt, um die Tastatureingabe des Spielers mit vorgegebenen Buchstaben zu vergleichen und die entsprechende Spielsteuerung einzuleiten.

Perl 6 versus Perl 5

Der Spielfluss in Listing 4 ist relativ selbsterklärend und wenn man die zur Implementierung notwendigen Codezeilen vergleicht, kommt Perl 6 besser weg. Auch die fehlenden runden Klammern bei den Einleitungen zu »for« – und »while« -Schleifen wirken sich positiv auf die Lesbarkeit aus.

Wird sich Perl 6 durchsetzen? Es ist zu früh, um diese Frage zu beantworten, der Praxistest wird sie entscheiden. Auf der Konferenz in Orlando setzte Larry Wall das Gerücht in die Welt, an einem Perl-6-Buch zu arbeiten, ließ aber offen, wie lange er zur Veröffentlichung braucht oder ob das Projekt überhaupt irgendwann Früchte tragen wird. Falls man ein paar Lehren aus der Vergangenheit ziehen sollte, dann die, dass einige Zeit ins Land ziehen könnte, bis sich etwas rührt in Larrys privatem Imperium.

Der Autor

Michael Schilli arbeitet als Software Engineer in der San Francisco Bay Area in Kalifornien. In seiner seit 1997 laufenden Kolumne forscht er jeden Monat nach praktischen Anwendungen der Skriptsprache Perl. Unter mailto:mschilli@perlmeister.com beantwortet er gerne Fragen.