---

Übersicht || 0:Vor | 1:Ge | 2:Theo | 3:Var | 4:Op | 5:IO | 6:{} | 7:Sub | 8:OOP | 9:Rx || A:Index | B: Tab | C:Tour | D:Delta | E:Links

---

Variablen

Sigils

In Perl beginnen alle Variablen mit einer Sigil. Sie markieren die 3 grundlegenden Variablentypen. Die vierte ist für ausführbare Einheiten, die fünfte für Abstraktionsebenen in denen die 4 organisiert sind.

$       Skalar, einzelner Wert beliebigen Datentyps
@       Array, indizierte Liste von Skalaren
%       Hash, als zweispaltige Tabelle vorstellbar, eindeutigen Schlüsseln (IDs) (keys), sind jeweils ein Wert  (value) zugeordnet
&       code/rule/token/regex
::      Abstraktion: package / module / class / role / subset / enum / type / grammar

Die Sigils können auch als Operatoren (Kontextualisierer) verwendet werden um diese und weitere (Daten-) Kontexte zu erzwingen.

Twigils

Oder auch segundäre Sigils, die auf ein $ (scalar), @ (array) oder % (hash) folgen, sind Marker für besondere Namensräume oder Variablen mit besonderen Eigenschaften.

  $foo. . . . normale variable (oder @foo oder %foo )
  $.foo . . . autogenerierter getter/setter methode (object attribute accessor )
  $^foo . . . autogenerierte positionale Parameternamen (für alle blöcke)
  $:foo . . . autogenerierte benannte Parameternamen (für alle blöcke)
  $*foo . . . globale Variable
  $+foo . . . Umgebungsvariable
  $?foo . . . konstante compiler hint variable, Zuweisung nur zur compiletime möglich
  $=foo . . . POD-Variable
  $<foo>. . . Matchvariable, kurzform für for $/{'foo'}
  $!foo . . . expliciter privatvariable eines Objektes (accessor), auch unter Schreibweise $foo zugreifbar)
  $~foo . . . Referenz auf Parserregex dieser Teilsprache (slang) 

Spezialvariablen

Sehr viele der alten Spezialvariablen wurde abgeschafft. Fast alle der jetzigen haben eine kurze und lange Version.

  $_ . . . . . . Kontextvariable
  $! . . . . . . Fehlermeldung (Ausnahme - exception)

  $/ . . . . . . zuletzt in diesem Block erzeugtes Matchobject
  $<...> . . . . alias auf benannte capture
  $0 .. $9 . . . alias auf nummerierte capture, ehemals $1 .. $9
  @(). . . . . . Array der $0 .. $9 und übrigen enthält die über $9 hinausgehen

  $*EXECUTABLE_NAME . vorher $0
  @*ARGS . . . . Argumente (Parameter) an das Script
  $*ARGFILES . . magischer Kommandozeilen-Input-Handle 
  $*CWD. . . . . Arbeitsverzeichnis (current working dir)
  $*IN . . . . . Standardeingabe
  $*OUT. . . . . Standardausgabe
  $*ERR. . . . . Standardfehlerausgabe
  $*PERL . . . . ausführende Perlversion
  $*LANG . . . . LANG variable from %*ENV that defines what human language is used
  @*INC. . . . . include pfade (aber nicht für Standardmodule), vorher @INC
  $*PID. . . . . aktuelle prozess id
  $*GID. . . . . reale gruppen id des Prozessbesitzers
  $*UID. . . . . reale id des Prozessbesitzers
  $*EGID . . . . effektive gruppen id des Prozessbesitzers
  $*EUID . . . . effektive id des Prozessbesitzers
  $*ON_WARN. . . , ehemals $SIG{__WARN__}
  $*ON_DIE . . . , ehemals $SIG{__DIE__}
  $*EMERGENCY_MEMORY . Notfall-Speicherbereich, vorher $^M
  %*ENV. . . . . Systemumgebung
  $*KERNEL . . . auf welchem Betriebssystem laufe ich gerade
  $*DISTRO . . . Softwarepaket, unter welcher Ditribution laufe ich gerade
  $*COMPILING . . 
  $*DEBUGGING . . 
    
  $?KERNEL . . . Für welches Betriebsystem kompiliert?
  $?DISTRO . . . Für welches Betriebsystemdistribution kompiliert?
  $?ARCH . . . . Softwarepaket, Wirtarchitektur
  $?XARCH. . . . Softwarepaket, Zielarchitektur
  $?VM . . . . . auf welcher virtuellen Maschine kompiliert?
  $?XVM. . . . . auf welcher virtuellen Maschine cross-kompiliert?
  $?PERL . . . . Perlversion für die kompiliert wurde
  %?LANG . . . . Grammar, die bei kompilierung aktuell waren # What is the current set of interwoven languages?
  $?GRAMMAR. . . Welche Grammar wurde für aktuelle Zeile benutzt?
  $?FILE . . . . aktuelle Datei
  $?MODULE . . . aktuelles Modul
  $?PACKAGE. . . aktuelles paket
  ::?CLASS. .  . aktuelle Klasse (als paketname)
  $?CLASS. . . . aktuelle Klasse (als variable)
  @?CLASS. . . . aktuelle Klassen
  $?ROLE . . . . aktuelle role (als variable)
  @?ROLE . . . . aktuelle roles
  &?ROUTINE. . . aktuelle sub oder methode
  @?ROUTINE. . . aktuelle subs oder methoden
  &?BLOCK. . . . aktueller Block
  $?LABEL. . . . labels des aktuellen Blocks
  $?LINE . . . . In welcher Zeile bin ich?

  @=COMMENT. . . alle Kommentarblöcke der Datei
  $=DATA . . . . data block handle (=begin DATA ... =end)
  @=DATA . . . . das selbe als array

  $~MAIN . . . . aktueller Hauptparser 
  $~Q. . . . . . Wurzel der Zitiersprache
  $~Quasi. . . . quasiquotingsprache
  $~Regex. . . . Regexregeln 
  $~P5Regex. . . Perl 5 Regex  regeln (:P5)
  $~Trans. . . . Regeln für tr Operationen

Namensräume

Bei deklarierung kann der Geltungsbereich (Namensraum) einer Variable mit folgenden Wörtern festgelegt werden.

  MY. . . . . . Symbole im aktuellen lexikalischen Namensraum (scope aka $?SCOPE)
  OUR . . . . . Symbole des aktuellen Paketes (aka $?PACKAGE)
  CORE. . . . . äußerster lexicalischer scope, Definition von Standard Perl
  GLOBAL. . . . interpreterweite Paketsymbole, in Wirklichkeit CORE::GLOBAL
  PROCESS . . . Prozessverwandte Globals (superglobals), CORE::PROCESS
  COMPILING . . lexikalische Symbole in the scope being compiled
  CALLER. . . . Kontextsymbole in the immediate caller's lexical scope
  CONTEXT . . . Kontextsymbole in my or any caller's lexical scope

Die folgenden relativen Bezeichnungen sind auch reserviert, aber können überall im Namen benutzt werden:

  OUTER . . . . Symbole des nächtäußeren lexikalischen Geltungsbereich
  UNIT. . . . . Symbole des äußersten lexikalischen Geltungsbereiches dieser Kompilierungseinheit
  SETTING . . . lexikalische Symbole in der DSL (gewöhnlich CORE) der Einheit
  PARENT. . . . Symbole im Elternpaket des Paketes (or lexical scope)

Die folgenden sind für den Anfang von Methodenaufrufen reserviert:

  SUPER . . . . Package symbols declared in inherited classes

Datentypen

Dies ist etwas mehr low level als die vorige Tabelle und dient eher dazu dem Interpreter mitzuteilen wie viel Platz diese Variable benötigt, das er es optimieren kann.

  int1
  int2
  int4
  int8
  int16
  int32       (aka int on 32-bit machines)
  int64       (aka int on 64-bit machines)

  uint1       (aka bit)
  uint2
  uint4
  uint8       (aka byte)
  uint16
  uint32
  uint64

  num32
  num64       (aka num on most architectures)
  num128

  complex32
  complex64   (aka complex on most architectures)
  complex128

  Str

Variablentypen

In der linken Spalte seht ihr Schlüsselworte für die verschiednen logischen Typen die Variablen in Perl 6 haben können.

Undefinierte Typen

  Mu          meist undefiniert
  Failure     Fehler (lazy exceptions, ausgeworfen wenn nicht passend behandelt)
  Any         Perl 6-Objekt (default Parametertyp einer Routine, ausser Junctions)
  Cool        Perl 6 geeignete Schleifenrückhalt "Convenient OO Loopbacks"
  Whatever    Platzhalter (wie Any, wird aber durch eine MMD im Sinne "tu was ich meine" augelöst)
  Int         beliebiges Integerobjekt
  Widget      beliebiges Widgetobjekt

Unveränderliche Typen

  Str         Perl String (endliche Sequenz aus Unicode Zeichen)
  Bit         einzelnes Perl Bit (erlaubt traits, aliasing, undef, etc.)
  Int         Perl Integer (erlaubt Inf/NaN, beliebige Genauigkeit, etc.)
  Num         Perl Zahlen
  Rat         Perl gebrochene Zahl (genaue Real, begrenzter Nenner)
  FatRat      Perl gebrochene Zahl (unbegrenzte Genauigkeit in beiden Teilen)
  Complex     Perl komplexe Zahlen (Zahlen mit i Anteil)
  Bool        Perl boolean (Bool::True oder Bool::False)
  Exception   Perl Ausnahme
  Block       ausführbaren Objekte mit lexikalischem Bereich für Variablen
  Seq         eine Liste an Werten (kann erst spät  (oder auch bequem - lazy) erzeugt werden)
  Range       ein Paar geordneter Endpunkte; erzeugt Unveränderbare (immutables) wenn iteriert
  Set         ungeordnete Wertesammlung das mehrfache Vorkommen nicht erlaubt
  Bag         ungeordnete Wertesammlung das Mehrfachvorkommen erlaubt
  Enum        ein unveränderliches Paar (Pair)
  EnumMap     Mapping von Enums mit eindeutigen Schlüsseln (fixer Hash)
  Signature   Parameter einer Funktion  (linksseites Binding)
  Parcel      Argumente in kommagetrennter Liste
  Slicel      Argumente in semikolongetrennter Liste (oder equiv, wie Z)
  Capture     Argumente eines Funktionsaufruf (rechtsseites Binding)
  Blob        eine undifferenzierte Masse von Bits
  Instant     ein Punkt in einem durchgängigen, aus atomaren Zeipunkten bestehenden, Zeitstrahl
  Duration    der Unterschied zwischen 2 Instant (Zeitpunkten)
  HardRoutine eine Routine, die sich nicht ändern möchte

Veränderliche Typen

  Iterator    Perl Liste
  SeqIter     Iterator über Seq
  RangeIter   Iterator über Range
  Scalar      Perl-Skalar
  Array       Perl-Array
  Hash        Perl-Hash
  KeySet      KeyHash of Bool (ein Set im listen/array Kontext)
  KeyBag      KeyHash of UInt (ein Bag im listen/array Kontext)
  Pair        einzelne Schlüssel-zu-Wert Assoziation
  PairSeq     eine Seq (Sequenz) Aus Paaren (Pair)
  Buf         Perl buffer (ein Array aus stringartigen Speicherplätzen)
  IO          Perl-Datei-Handle
  Routine     Basisklasse für alle "wrap"-fähigen, ausführbaren Objekte
  Sub         Perl-Subroutine
  Method      Perlmethode
  Submethod   Perl-Subroutine, die sich wie eine Methode verhält
  Macro       zur Kompilierungszeit ausgeführte Perl-subroutine
  Regex       Perl Suchmuster
  Match       Perl Suchfund, normalerweise durch Anwendung einer Regex gebildet
  Stash       ein Hash (package, module, class, lexpad, etc) in der Symboltabelle
  SoftRoutine Routine die veränderlich bleiben will

Introspektion

von Objekten

  WHAT        prototyp des objekttyps, Kurzname im Stringkontext
  WHICH       ID des Objektes
  WHO         package, daß dieses Objekt unterstützt, langer Name im Stringkontext
  WHERE       Speicheradresse des Objektes
  HOW         Object der Metaklasse: "Higher Order Workings"
  WHEN        (reserviert für Ereignisse (events) ?)
  WHY         (reserviert für Dokumentation?)
  WHENCE      autovivification von closures (Blöcken)

Operatoren

Vorrangtabelle

V steht für Vorrang (ob linke (L) oder rechte (R) Seite des Operators bevorzugt), aka Assoziativität, siehe nächste Tabelle.

  V  Level               Beispiele
  =  =====               ========
  N  Ausdrücke           42 3.14 "eek" qq["foo"] $x :!beliebig @$array
  L  Methoden postfix    .name .+ .? .* .() .[] .{} .<> .«» .:: .= .^ .:
  L  Autoinkrement       ++ --
  R  potenzieren         **
  L  symbolische unäre   ! + - ~ ? | +^ ~^ ?^ \ ^ =
  L  multiplizierende    * / % +& +< +> ~& ~< ~> ?& div mod
  L  addierende          + - +| +^ ~| ~^ ?| ?^
  N  wiederhohlend       x xx
  L  verbindend          ~
  X  junctives und       &    (all)
  X  junction oder       | ^  (any)
  L  benannte unäre      rand sleep abs etc.
  N  nichtkettend infix  but does <=> leg cmp .. ..^ ^.. ^..^
  C  verkettend infix    != == < <= > >= eq ne lt le gt ge ~~ === eqv !eqv
  L  und (hoh. Vorrang)  &&
  L  oder (hoh. Vorrang) || ^^ // min max
  L  bedingt             ?? !! ff fff
  R  Zuweisungen         = := ::= => += -= **= xx= .=
  L  schwache unäre      true not
  X  Kommaoperator       , p5=>
  X  listen op (infix)   Z minmax X X~ X* Xeqv
  R  listen op (prefix)  : print push say die map substr ... [+] [*] any $ @
  L  schwaches und       and andthen
  L  schwaches oder      or xor orelse
  N  Ausdruck Begrenzer  ; <==, ==>, <<==, ==>>, {...}, Ausdruckmodifikatoren, unless, extra ), ], }

Assotiativität

  V  Assoziation   setzt $a op $b op $c wie folg um:
  =   ===========   =================================
  L   links         ($a op $b) op $c
  R   rechts         $a op ($b op $c)
  N   keine          ILLEGAL
  C   verkettend    ($a op $b) and ($b op $c)
  X   liste          op($a, $b, $c) or op($a; $b; $c)

Kategorien

Um Operatoren oder Schlüsselwörter mit einem Macro selber zu erstellen, muß bei der Definition die Kategorie angegeben werden.

  category:<prefix>
  circumfix:<( )>
  dotty:<.>
  infix:<+>
  infix_circumfix_meta_operator:{'»','«'}
  infix_postfix_meta_operator:<=>
  infix_prefix_meta_operator:<!>
  package_declarator:<class>
  postcircumfix:<( )>
  postfix:<++>
  postfix_prefix_meta_operator:{'»'}
  prefix:<++>
  prefix_circumfix_meta_operator:{'',''}
  prefix_postfix_meta_operator:{'«'}
  q_backslash:<\\>
  qq_backslash:<n>
  quote_mod:<c>
  quote:<q>
  regex_assertion:<?>
  regex_backslash:<w>
  regex_metachar:<.>
  regex_mod_internal:<i>
  routine_declarator:<sub>
  scope_declarator:<my>
  sigil:<$>
  special_variable:<$!>
  statement_control:<if>
  statement_mod_cond:<if>
  statement_mod_loop:<while>
  statement_prefix:<do>
  term:<*>
  trait_auxiliary:<is>
  trait_verb:<of>
  twigil:<?>
  type_declarator:<subset>
  version:<v>

Metaoperatoren

Metaoperatoren werden mit einem beliebigen einfachen Operator kombiniert (ihm voran gestellt), um ihn zu parallelisieren oder sonstwie erweitert oder verändert anzuwenden. In den Beispielen steht W für Wert L für linker wert und R für rechts und E für Ergebnis. Eine nachstehende zahl ist der index eines Arrays.

  =  selbstzuweisend   Zuweisung in den linken Operanden (wie aus P5 bekannt)
                       $L op= $R entspricht: $L = $L op $R 
  !     negierend      Ergebnis wird negiert (wie aus P5 bekannt)
                       $L !op $R entspricht: !($L op $R )
  R     reverse        vertauscht Operatoren
                       $E = $L Rop $R entspricht: $E = $R op $L
  S     sequence       erzwingt sequentielle Ausführung - verbietet jede parallel Ausführung
  >>    hyper          verarbeitet parallel (eager) Arrays oder wendet einzelnen Wert auf Array an; 
                       Spitze zeigt zur Seite, die Dimensionalität des Ergebnisses vorgibt
                       @E = $L op>> @R entspricht: @E = $L op R1, $L op R2, ...;
                       @E = @L op>> @R entspricht: @E = L1 op R1, L2 op R2, ...;
  [ ]  .reduce()       wendet den Op auf einen Array von Werten an; 
                       $E = [op] @W entspricht: $E = W1 op W2 op  ...;
  [\ ] .triangle()     ähnlich wie vorher, erzeugt aber einen Array surch:
                       @E = W1, W1 op W2, W1 op W2 op W3,  ...;
  X    .crosswith()    wendet op auf alle Paare eines Kartesischen Prokuktes an;
                       @E = L1 op R1,  L1 op R2,  L2 op R1, L2 op R2...;
  Z    .zipwith()      verbindet Listenelemente gleicher Position mit dem Operator zu Element der Ergenisliste; wie hyper nur lazy
                       @E = L1 op R1,  L2 op R2 ...;

Unicodeoperatoren

<< >> können auch mit den Unicode symbolen "Chevron" geschrieben werden.

  « aka <<
  » aka >>

Kontextualisierer

Sind prefixe Operatoren oder Funktionen die diverse Kontexte von Variablentypen und Datentypen erzwingen können.

  $()    scalar()    skalarer Kontext
  @()    array()     Arraykontext
  @@()   slice()     Slicekontext
  %()    hash()      Hashkontext
  ?                  boolscher Kontext
  +                  numerischer kontext
  ~                  Stringkontext
  |                  überführt Captureobjekte in eine Argumentenliste
  ||                 überführt Captureobjekte in eine Semikolonliste
  &                  Kodereferenz

Dateitestoperatoren

Die werden mit smartmatch (~~) angewendet oder als methode des Dateihanles. "datei.txt" ~~ :e ; $dateiname.e

  :r   Datei ist lesbar von effektiven uid/gid
  :w   Datei ist beschreibbar von effektiven uid/gid
  :x   Datei ist ausführbar von effektiven uid/gid
  :o   effektive uid besitzt Datei

  :R   Datei ist lesbar von realen uid/gid
  :W   Datei ist schreibbar von realen uid/gid
  :X   Datei ist ausführbar von realen uid/gid
  :O   reale uid besitzt Datei

  :e   Datei existiert
  :s   Datei hat Größe größer 0

  :f   Datei ist eine einfache Datei
  :d   Datei ist ein Verzeichnis
  :l   Datei is ein symbolische Verknüpfung
  :p   Datei ist eine benannte pipe (FIFO), oder der Dateihandle ist eine pipe
  :S   Datei ist ein socket
  :b   Datei ist eine block special Datei (z.B. HDD, RAM-Bereich, CDROM)
  :c   Datei ist eine character special Datei (z.B. terminals, modems)
  :t   Dateihandle ist geöffnet zu einem tty (terminal)

  :u   Datei hat setuid bit gesetzt
  :g   Datei hat setgid bit gesetzt
  :k   Datei hat sticky bit gesetzt

Smartmatch

$_	X	Type of Match Wanted	What to use on the right
Array	Num	array element truth	.[X]
Array	Num	array contains number	*,X,*
Array	Str	array contains string	*,X,*
Array	Seq	array begins with seq	X,*
Array	Seq	array contains seq	*,X,*
Array	Seq	array ends with seq	*,X
Hash	Str	hash element truth	.{X}
Hash	Str	hash key existence	.{X}:exists
Hash	Num	hash element truth	.{X}
Hash	Num	hash key existence	.{X}:exists
Buf	Int	buffer contains int	.match(X)
Str	Char	string contains char	.match(X)
Str	Str	string contains string	.match(X)
Array	Scalar	array contains item	.any = X
Str	Array	array contains	string X.any
Num	Array	array contains	number X.any
Scalar	Array	array contains object	X.any
Hash	Array	hash slice exists	.{X.all}:exists .{X.any}:exists
Set	Set	subset relation	.{X}:exists
Set	Hash	subset relation	.{X}:exists
Any	Set	subset relation	.Set.{X}:exists
Any	Hash	subset relation	.Set.{X}:exists
Any	Set	superset relation	X.{$_}:exists
Any	Hash	superset relation	X.{$_}:exists
Any	Set	sets intersect	.{X.any}:exists
Set	Array	subset relation	X,* # (conjectured)
Array	Regex	match array as string	.Cat.match(X); cat(@$_).match(X)

Kommentierops

Quoting bedeutet zitieren, also in Anführungszeichen stellen. "Q", der einfachste, generische Anführungsoperator wandelt den umschlossenen Text in einen String um, ohne jede Bearbeitung. Diese wird mit den beigefügten Adverbien gesteuert. Und so entsprechen die bekannten quoting operatoren einem "Q" mit folgenden Beifügungen.

  q//         Q :q //
  ' '         Q :q //
  qq//        Q :qq //
  " "         Q :qq //
  qw//        Q :q :w //
  < >         Q :q :ww //
  << >>       Q :qq :ww //
  qp//        Q :p //
  qx//        Q :x //
  rx//        Q :regex //
  m///        Q :match ///
  mm///       Q :match :sigspace ///
  s///        Q :subst ///
  ss///       Q :subst :samespace ///
  tr///       Q :trans ///

Textverarbeitung

Kommentieradverbien

Es gibt noch weit mehr Adverbien, die selbstverständlich jedem Kommentieroperator, beigefügt werden können wie z.B.: q:s/.../. Die genannten Adverbien sind in Wirklichkeit Sammelbefehle für mehrere Adverbien, mit denen sich die Wirkungsweise noch feiner abstimmen läßt.

  kurz     lang                Bedeutung
  ----    ------         ----------------------------------
  :x      :exec          führt aus und fügt Ergebnis ein (ehemals qx() )
  :w      :words         spaltet Ergebnis in Worte ("" werden normale Zeichen)  (ehemals qw())
  :ww     :quotewords    spaltet Ergebnis in Worte (beachtet Anführungszeichen)
  :q      :single        interpoliert \\, \q und \' (oder whatever)
  :qq     :double        interpoliert mit :s, :a, :h, :f, :c, :b
  :s      :scalar        interpoliert $ variablen
  :a      :array         interpoliert @ variablen
  :h      :hash          interpoliert % variablen
  :f      :function      interpoliert & Aufrufe
  :c      :closure       interpoliert {...} Ausdrücke (Blöcke)
  :b      :backslash     interpoliert Steuerzeichen (\n, \t, ...), impliziert mind. :q
  :p      :path          Dateipfadangaben
  :to     :heredoc       bestimmt parameter als heredoc terminator
          :regex         liest ein als regex
          :match         liest ein als regex und wendet sie zur Suche an
          :subst         liest ein als Ersetzung
          :trans         liest ein als Transliteration
          :code          liest ein als Quellcode (Quasiquoting)

Regex Modifikatoren

Das sind Adverbien die nach dem regex-Befehl eingefügt werden (wie :i in m :i / .../), um das Verhalten der Regex zu steuern, den Suchbereich einzugrenzen und um vornhinein klarzustellen, wonach gesucht wird.

 kurz        lang                         Bedeutung
 ----    -------------        ---------------------------------------------
 :g      :global              sucht nach jedem Vorkommen anstatt nur einmal
 :x(n)                        sucht nur n Vorkommen
 :nth(n) :1st :2nd :3rd :5th  sucht das n-te Vorkommen
 :c(n)   :continue            sucht ab der Position n (ab 0)
 :p(n)   :pos                 sucht nur an der Position n (ab 0)
 :ov     :overlap             sucht an allen Positionen einmal (aktiviert Backtracking)
 :ex     :exhaustive          sucht an allen Positionen so oft wie fündig (aktiviert Backtracking)
         :ratchet             deaktiviert backtracking
         :panic               überschreibt mögliches :ratchet aller Teilregex (aktiviert Backtracking)
         :keepall             Teilregex sollen sich alles merken
 :rw                          Regex hat das Recht den String zu ändern
 :s      :sigspace            Leerzeichen sind Trenner zw. Teilausdrücken, keine zu suchenden Leerzeichen
 :ss     :samespace           Ersetzen mit :s, Fund von Wort 1 zu 1. Ausdruck usw.  (ss/aht udn/hat und/;)
 :i      :ignorecase          beachtet Gross/kleinschreibung nicht
 :ii     :samecase            ersetzter String beachten Gross/kleinschreibung des Fundes
 :a      :ignoreaccent        Buchstaben mit & ohne Akzent (Strich o. Symbol darüber) sind gleich
 :aa     :sameaccent          ahmt beim Ersetzten Akzente des Fundes nach
         :bytes               nimmt Bytes als Atome
         :chars               sucht auf Zeichenebene
         :codes               codepoints markieren Positionen
         :graphs              sprachunabhängige Grapheme werden gesucht
 :P5     :Perl5               benutze Perl 5 Regex Syntax und Regeln

Regex Metazeichen

Innerhalb einer Regex haben folgende Zeichen eine besondere Bedeutung.

  .         beliebiger Buchstabe
  ^         Stringanfang
  $         Stringende
  ^^        Zeilenanfang
  $$        Zeilenende
  ( )       umschließt Teilregex (Gruppe) deren Ergebnis erfasst/gespeichert (capture) wird
  [ ]       nicht erfassende/gespeicherte Gruppe
  { }       closure, auszuführender Block innerhalb der Regex
  < >       suche eine Teilregel (subrule)
  **        multipliziert (verfielfacht) Zeichen oder Teilregex (links) um Anzahl (rechts)
  |         verknüpft alternative Muster (oder-Verbindung (OR))
  &         verknüpft Muster die aller erfüllt sein müssen (AND)
  \         leitet escape sequenzen und Steuerzeichen ein     
  #         eröffnet Kommentar der bis zum Zeilenende geht
  :=        bindet suchfund an hypothetische Variable

Steuerzeichen

Folgende Sequenzen werden in Zitaten bei aktiviertem ":b" oder ":backslash" (in "", qq und <<>> inklusive) zu nicht sichtbaren Steuerzeichen evaluiert. Sie gelten auch innerhalb von Regexen, weswegen sie alle auch in der nachfolgenden Liste erscheinen.

  \a          BELL
  \b          BACKSPACE
  \t          TAB
  \n          LINE FEED
  \f          FORM FEED
  \r          CARRIAGE RETURN
  \e          ESCAPE

Escape Sequenzen

Während Steuerzeichen in Strings evaluiert werden in denen das Adverb :b aktiviert ist (meist auch gleichlautend in Regex), werden folgende Escapesequenzen nur von regulären Ausdrücken verstanden. Der allen Zeichen vorrangehene Backslash (\) zeigt an das folgende Buchstaben nicht wörtlich genommen werden sondern eine Sonderbedeutung haben. Das wird im englisschen auch escapen (flüchten) genannt.

  \0[ . . . ]     Zeichen mit diesem oktalen ASCII-Wert (Klammern optional)
  \b              Wortgrenze (Zeichen das an Leerzeichen (\s) grenzt )
  \B              keine Wortgrenze
  \c[ . . . ]     ein benannntes oder Kontrollzeichen
  \C[ . . . ]     alles außer dem benannten Buchstaben oder Kontrollzeichen
  \d              eine Ziffer
  \D              Zeichen die keine Zifferns sind
  \e              ein "escape"-Zeichen (beginnt meist mit \)
  \E              alles außer \e.
  \f              "form feed" Steuerzeichen (FF)
  \F              alles außer "form feed"
  \n              Finde einen (logischen) Zeilenumbruch (LF).
  \N              Finde alles außer einem (logischen) Zeilenumbruch
  \h              Finde horizontale Leerzeichen
  \H              Finde alles außer \h.
  \L[ . . . ]     alles innerhalb der Klammern sind Kleinbuchstaben
  \Q[ . . . ]     alle Metazeichen in Klammern haben keine Metabedeutung
  \r              return-Zeichen (CR)
  \R              alles außer \r
  \s              beliebige Lerzeichen (\t | \h | \v) 
  \S              alles ausser Leerzeichen
  \t              ein tab (unsichbares Tabulatorzeichen)
  \T              alles außer \t
  \U[ . . . ]     alles innerhalb der Klammern sind Großbuchsten
  \v              vertikale Leerzeichen
  \V              alles außer \v
  \w              Wortzeichen (Unicode alphanumerisch + "_")
  \W              alles außer \w
  \x[ . . . ]     finde ein Zeichen, als Hexadezimalzahl gegeben (Klammern optional)
  \X[ . . . ]     finde alles außer dem in hex angegebenen  Zeichen (Klammern optional)

Teilregeln

Werden normalerweise zur wiederverwendung durch =grammar=s definiert. Aber Perl 6 geht schon mit einigen Nützlichen an den Start.

  <ws>            Whitespace - Leerzeichen aller Art

Ablaufkontrolle

Wird ausführlicher auf Tafel 6 behandelt.

Sonderblöcke

Sonderblöcke oder auch closure traits werden intern als Codereferenzen gespeichert, die Kompilierungszeiteigenschaften (traits) des umgebenden Blockes sind. Sie können in jedem Block vorkommen, es sei ihre Funktion kann nur unter bestimmten Bedingungen erfüllt werden, was hier dann auch explizit geschrieben steht. Die mit * Gekennzeichneten können auch in Ausdrücken verwendet werden.

    BEGIN {...}*      zur compilezeit, so füh wie möglich, nur 1x ausgeführt 
    CHECK {...}*      zur compilezeit, so spät wie möglich, nur 1x ausgeführt 
     INIT {...}*      zur Laufzeit, so füh wie möglich, nur 1x ausgeführt 
      END {...}       zur Laufzeit, so spät wie möglich, nur 1x ausgeführt 

    START {...}*      bei ersten Ausführung, einmal je Klone

    ENTER {...}*      vor jeder Ausführung, mehrmals bei Schleifen
    LEAVE {...}       während jeden Verlassen des Blocks
     KEEP {...}       bei jedem erfolgreichem Blockaustritt, teil der LEAVE queue
     UNDO {...}       bei jedem nicht erfolgreichem Blockaustritt, teil der LEAVE queue

    FIRST {...}*      bei Initialisierung einer Schleife, vor ENTER
     NEXT {...}       beim Sprung in die nächste Iteration einer Schleife, vor jedem LEAVE
     LAST {...}       beim Verlassen einer Schleife, nach jedem LEAVE

      PRE {...}       definiert Vorbedingungen für einen Block vor ENTER
     POST {...}       definiert Nachbedingungen für einen Block nach LEAVE

    CATCH {...}       fängt jede Ausnahme vor LEAVE ab
  CONTROL {...}       fängt Ausnahmen von Steuerungsbefehlen (wie next/last/return etc.) vor LEAVE ab

Sprungbefehle

detailierte Erklärung

  goto       springe zu einem definierten Label ( "Labelname:\n")
  redo       wiederhohle diese Iteration der Schleife
  next       springe zur nächsten Iteration dieser Schleife
  last       verlasse diese Schleifenblock
  break      verlasse diesen "when"-Bedingungsblock
  leave      verlasse diese Block mit einem Rückgabewert
  return     verlasse diese Routine mit einem Rückgabewert

Bedingte Ausführung

detailierte Erklärung

  if         wenn nachfolgende Bedingung wahr/positiv ist, wird darauf folgende Block ausgeführt
  elsif      wie "if"; Wird nur beachtet, wenn keiner der vorangegangenen "if"- oder "elsif"-Ausdrücke positiv wahr
  else       führt nachfolgenden Block aus, wenn keine vorrangegangene "if" oder "elsif" Klausel ausgeführt wurde
  unless     Gegenteil von if, kein elsif oder else darf folgen
  given      setzt $_ und leitet Block mit "when"-Bedingungen ein
  when       führt smartmatch gegen $_ aus, wenn Ergebnis wahr/positiv, wird darauf folgende Bedingung ausgeführt
  default    führt nachfolgenden Block aus, wenn keine vorrangegangene "when" Klausel ausgeführt wurde

Schleifen

detailierte Erklärung zu Schleifen

  loop       Endlosschleife, kann auch als C-artige benutzt werden wie in Perl 5: "for ($a=1; $a++; $a>5) {... "
  repeat     leitet while- oder until-Schleifen ein, deren Bedingung am Blockende ist
  while      wiederholt solange der Ausdruck wahr ist
  until      wiederholt bis der Ausdruck wahr ist
  for        iteriert über einen Array wie in Perl 5: "for (@a) { ...", setzt $_ und kann daher auch mit "when" kombiniert werden

Routinen

Routinendefinitionen: [Namensraum] [Modus] Typ [Name] [Eigenschaft] (Signatur) { Block }

Routinetypen

  sub            einfache Routine
  method         vererbbare Objektmethode
  submethod      nicht vererbbare Methode
  regex          Routine die einen regulären Ausdruck ausführt
  rule           Alias auf "regex :ratchet :sigspace"
  token          Alias auf "regex :ratchet"
  macro          zur Kompilierungszeit ausgeführt, liefert AST

Routinenmodi

  multi          Routinen die gleichnamige Geschwister haben können, bei Aufruf wird Kandidat mit passender Signatur ausgewählt
  only           Routinen die keine gleichnamigen Geschwister in diesem Block haben dürfen (ist Standard, muss nicht angegeben werden)
  proto          Prototyp, nur für multis, wenn keine Signatur passt, wir gleichnamige proto aufgerufen

Routineneigenschaften

  signature      definiert Signatur einer Routine (Aufzählung aller Parameter - meist implizit durch runde Klammern)
  will do        definiert Block einer Routine (meist implizit durch geschweifte Klammern)
  as             innerer Rückgabetyp
  of             offizieller Rückgabetyp
  rw             Routine als lvalue benutzbar, man kann ihr zuweisen
  cached         markiert eine routine deren Ergebnisse gespeichert (gepuffert - memoized) werden
  parsed         hygienisches macro, nur bisher definierte darin bekannt
  reparsed       nicht hygienisches macro, später definierte sind bekannt
  tighter        definiert Operator mit höherer Priorität als dem zum Vergleich angegebenen 
  looser         definiert Operator mit niedrigerer Priorität als dem zum Vergleich angegebenen 
  equiv          definiert Operator gleichen Priorität als dem zum Vergleich angegebenen 
  assoc          definiert Assoziativität eines Operators

Zum Vergleich: Variablentypen, Vorrangtabelle und Assotiativitäten

Parametereigenschaften

  readonly       unveränderliche Parameter (Konstanten)
  rw             veränderliche Parameter (rw steht für: read write - lesen schreiben)
  copy           erzeugt schreibbare Kopie der Originalarguments ("pass-by-value")
  dynamic        Parameter ist im gesamten lexicalischen Bereich sichtbar (wie local in Perl 5)
  parcel         roher Zeiger, der nicht aufgelöst (contextualisiert) wird

---

Übersicht || 0:Vor | 1:Ge | 2:Theo | 3:Var | 4:Op | 5:IO | 6:{} | 7:Sub | 8:OOP | 9:Rx || A:Index | B: Tab | C:Tour | D:Delta | E:Links

---

-- HerbertBreunung - 16 Apr 2006