=head1 Perl 6 table index

This is the POD version of http://www.perlfoundation.org/perl6/index.cgi?perl_table_index

=head1 AUTHORS

This POD was generated by Ahmad M. Zawawi <ahmad.zawawi@gmail.com> via the tool:
http://svn.perlide.org/padre/trunk/Padre-Plugin-Perl6/parse_perl6_table_index.pl

For authors of the original wiki place, see:
http://www.perlfoundation.org/perl6/index.cgi?action=revision_list;page_name=perl_table_index

=head1 LICENSE

Copyright (c) 2006-2009 under the same (always latest) license(s) used by the Perl 6 /src 
branch of the Pugs trunk.

=head1 Table index

=head2 C<<< ! >>>

=over

=item - logical negation, forces binary context;

=item (twigil) - twigil of private class and object variables

=back

=head2 C<<< !! >>>

=over

=item - second Part of the ternary (conditional) operator after ??

=back

=head2 C<<< !!! >>>

=over

=item (yadda op) - yadda Operator that calles die

=back

=head2 C<<< !< >>>

=over

=item - not less, synonym for ">="

=back

=head2 C<<< !<= >>>

=over

=item - not less or equal, weird synonym for ">"

=back

=head2 C<<< != >>>

=over

=item - compare op, true if numeric unequal, short for "!=="

=back

=head2 C<<< !=:= >>>

=over

=item - compare op, tests negated on binding

=back

=head2 C<<< !== >>>

=over

=item - compare op, tests inequality in numeric context, negated form

=back

=head2 C<<< !=== >>>

=over

=item - compare op, tests identity, negated form

=back

=head2 C<<< !> >>>

=over

=item - synonym for "<="

=back

=head2 C<<< !>= >>>

=over

=item - synonym for "<"

=back

=head2 C<<< !eq >>>

=over

=item - synonym for "ne"

=back

=head2 C<<< !eqv >>>

=over

=item - negated form of dynamic equivalence

=back

=head2 C<<< !ge >>>

=over

=item - synonym for "lt"

=back

=head2 C<<< !gt >>>

=over

=item - synonym for "le"

=back

=head2 C<<< !le >>>

=over

=item - synonym for "gt"

=back

=head2 C<<< !lt >>>

=over

=item - synonym for "ge"

=back

=head2 C<<< !~~ >>>

=over

=item - negated smartmatch operator

=back

=head2 C<<< "" >>>

=over

=item (quoting op) - double quoting, interpolate with :s, :a, :h, :f, :c, :b (all vars, functions, blocks, control chars), alias to qq//*

=back

=head2 C<<< # >>>

=over

=item - starts a comment that continues to the end of the line or bracket

=back

=head2 C<<< $ >>>

=over

=item (sigil) - prefix of scalar vars, operator to force scalar context

=item (regex Metachar) - end of the string

=back

=head2 C<<< $$ >>>

=over

=item (regex Metachar) - end of a line

=back

=head2 C<<< % >>>

=over

=item (sigil) - prefix of hash variables

=item - gives remainder of a modulo division, forces numeric context

=back

=head2 C<<< & >>>

=over

=item (conext op) - sigil of coderefs

=item - junctive and, requires that all conditions are met

=back

=head2 C<<< && >>>

=over

=item - logical and, conditonal statements, ends evaluation on the first false expression, returns boolean result

=back

=head2 C<<< '' >>>

=over

=item (quoting op) - simple quoting, just / and ' needs o be quoted, alias to q//

=back

=head2 C<<< () >>>

=over

=item - grouping of values (parameters)

=item (regex Metachar) - encompass a subregex/submatch

=back

=head2 C<<< * >>>

=over

=item (scalar num op) - multiplies numbers and forces numeric context on parameters;

=item (term) - synonym for Inf (Whatever) in connection with a Range operator (".."); marks the end of an array in a slice operator so that negative indices access array elements relative to one beyond the final element

=item - marks as prefix slurpy arrays in signatures

=item (twigil) - secondary sigil of global variables

=back

=head2 C<<< ** >>>

=over

=item (scalar num op) - raises a number to a power and forces numeric context

=item (regex Metachar) - multiplies char or group like x (scalar strig op) outside of regex, (ha)**3 equals (hahaha)

=back

=head2 C<<< + >>>

=over

=item (conext op), (scalar num op) - forces numeric context of values and adds results

=back

=head2 C<<< +& >>>

=over

=item (scalar num op) - bitwise and, numeric context

=back

=head2 C<<< ++ >>>

=over

=item (prefix & suffix op) - generic autoincrement, calls internal iterator of that object, before (prefix) or after (suffix) the evaluation of the surrounding term

=back

=head2 C<<< +< >>>

=over

=item (scalar num op) - shift left in numeric kontext

=back

=head2 C<<< +> >>>

=over

=item (scalar num op) - shift right in numeric kontext

=back

=head2 C<<< +^ >>>

=over

=item (scalar num op) - bitwise xor in numeric context

=back

=head2 C<<< +| >>>

=over

=item (scalar num op) - bitwise or in numeric context

=back

=head2 C<<< , >>>

=over

=item - list generating operator

=back

=head2 C<<< - >>>

=over

=item - forces numeric context and subtract

=back

=head2 C<<< -- >>>

=over

=item (prefix & suffix op) - generic autodecrement, calls internal iterator of that object, before (prefix) or after (suffix) the evaluation of the surrounding term

=back

=head2 C<<< --> >>>

=over

=item - alternative syntax to type a parameter

=back

=head2 C<<< . >>>

=over

=item - secondary sigil for public accessors (getter/setter)

=item (regex Metachar) - really any character (unlike Perl 5)

=back

=head2 C<<< .. >>>

=over

=item - range generating operator; range object in scalar context, see smartmatch table

=back

=head2 C<<< ... >>>

=over

=item (yadda op) - yadda Operator that calles fail (exception)

=back

=head2 C<<< / >>>

=over

=item - division, numeric context

=back

=head2 C<<< // >>>

=over

=item - err operator, returns the first defined value

=back

=head2 C<<< : >>>

=over

=item - pair generation operator

=item (filetest op) - start of all file text ops, syntax: ":" ~ one (<r w x o R W X O e z s f d l p S b c t u g k T B M A C>)

=item (twigil) - for autogenerated named parameters of a block

=item - converts (decimal) numbers to another base, number of base follows after the ":"

=item - marks as prefix named parameter in a signature

=item - (flow control) - endchar of all labels, jou can jump to (see also goto)

=back

=head2 C<<< :: >>>

=over

=item - name space separator (like in Perl 5)

=back

=head2 C<<< ::= >>>

=over

=item - binding at compile time

=back

=head2 C<<< := >>>

=over

=item - creates an alias to a variable (binding)

=back

=head2 C<<< ; >>>

=over

=item - seperates commands (statements) or array indices eg @[2;3] instead of @a[2][3]

=back

=head2 C<<< < >>>

=over

=item less than, numeric comparison operator

=back

=head2 C<<< <-> >>>

=over

=item double pointy syntax to assign a rw parameter to a block

=back

=head2 C<<< << >>>

=over

=item (meta op) - applies the operator on the left as hyper operator to the array on the right

=back

=head2 C<<< <<== >>>

=over

=item - leftward pointing feed operator that adds values to an existing list (append-mode)

=back

=head2 C<<< <<>> >>>

=over

=item (quoting op) - circumfix quoting operator for grouping with autoquoting and evaluation (alias to Q :qq :ww /.../)

=back

=head2 C<<< <= >>>

=over

=item - less than or equal, numeric comparison operator

=back

=head2 C<<< <== >>>

=over

=item - leftward pointing feed operator

=back

=head2 C<<< <=> >>>

=over

=item - numeric less-equal-greater comparison for Order class

=back

=head2 C<<< <> >>>

=over

=item (quoting op) - circumfix quoting operator for grouping with autoquoting (alias to Q :q :ww /.../)

=back

=head2 C<<< <op>= >>>

=over

=item (meta op) - self assignment, left side is one oper and the result is assigned to ($a += 3; equals $a = $a + 3)

=back

=head2 C<<< <var>[] >>>

=over

=item - postcircumfix operator, appended on an array var, returns an array slice with values which indexes was inside the brackets

=back

=head2 C<<< = >>>

=over

=item (Op) - assignment, left side is evaluated and assigned to the right

=back

=head2 C<<< =:= >>>

=over

=item (Op) - compares binding, if both vars are bound to same memory location

=back

=head2 C<<< == >>>

=over

=item (Op) - equality of value (numeric)

=back

=head2 C<<< === >>>

=over

=item (Op) - equality of value and type

=back

=head2 C<<< ==> >>>

=over

=item (Op) - rightward pointing feed operator

=back

=head2 C<<< ==>> >>>

=over

=item (Op) - rightward pointing feed operator that adds values to an existing list (append-mode)

=back

=head2 C<<< => >>>

=over

=item (Op) - pair (and hash) constructor, fatarrow

=back

=head2 C<<< > >>>

=over

=item (Op) - greater than, numeric comparison operator; ends grouping with autoquoting (formerly qw())

=back

=head2 C<<< >= >>>

=over

=item (Op) - greater than or equal, numeric comparison Op

=back

=head2 C<<< >> >>>

=over

=item (meta op) - binds operator (right) as hyper operator to an array (left)

=back

=head2 C<<< ? >>>

=over

=item (conext op) - forces binary context in an expression

=item - marks as postfix optional parameters in signatures

=item - quantifier for 0 or 1 occurrence in Regexes

=item (twigil) - secondary sigil for constant compiler hint variables

=back

=head2 C<<< ?& >>>

=over

=item - logical op, and combinator, forces binary context

=back

=head2 C<<< ?? !! >>>

=over

=item - ternary or conditional operator

=back

=head2 C<<< ??? >>>

=over

=item (yadda op) - yadda operator that calles warn

=back

=head2 C<<< ?^ >>>

=over

=item - logical xor, forces operands into boolean context

=back

=head2 C<<< ?| >>>

=over

=item - logical or, forces operands into boolean context

=back

=head2 C<<< @ >>>

=over

=item (sigil) - sigil of an array

=back

=head2 C<<< @@ >>>

=over

=item (conext op) - sigil for multislice context, meaning an array that may contain array references

=back

=head2 C<<< A >>>

=over

=item (filetest op) - Script start time minus file access time, in days

=back

=head2 C<<< B >>>

=over

=item (filetest op) - file is a binary data file (opposite of :T)

=back

=head2 C<<< BEGIN >>>

=over

=item (closure trait) - special Block, is executed in compile time

=back

=head2 C<<< C >>>

=over

=item (filetest op) - Script start time minus inode change time (Unix, may differ for other platforms)

=back

=head2 C<<< Code >>>

=over

=item - data typ for code references of any kind  

=back

=head2 C<<< Failure >>>

=over

=item - data type for an error thrown by an unhandled exception

=back

=head2 C<<< Inf >>>

=over

=item - infinity, to generate infinite lazy lists

=back

=head2 C<<< M >>>

=over

=item (filetest op) - Script start time minus file modification time, in days

=back

=head2 C<<< O >>>

=over

=item (filetest op) - tests if file is owned by real uid

=back

=head2 C<<< P5 >>>

=over

=item (regex modifier) - activate old Perl 5 regex rules, alias to :Perl5

=back

=head2 C<<< Pair >>>

=over

=item - data type

=back

=head2 C<<< Perl5 >>>

=over

=item (regex modifier) - activate old Perl 5 regex rules, alias to :P5* pick (array method) - select a number of random vaues

=back

=head2 C<<< Q >>>

=over

=item (generalized quoting op) - understands a list of adverbs

=back

=head2 C<<< R >>>

=over

=item <op> (meta op) - reverse operands

=item (filetest op) - check if file is readable by real uid/gid

=back

=head2 C<<< S >>>

=over

=item (filetest op) - file is a socket

=back

=head2 C<<< T >>>

=over

=item (filetest op) - file is an ASCII text file (heuristic guess), (opposite of :B)

=back

=head2 C<<< W >>>

=over

=item (filetest op) - check if file is writeable by real uid/gid

=back

=head2 C<<< Whatever >>>

=over

=item - an undefined type used as wildcard (like undef) (S12)

=back

=head2 C<<< X >>>

=over

=item (list op) - Cross product of two arrays, eg 1,2 X 3,4 == 1,3,1,4,2,3,2,4 ; alias of comb method

=item <op> (meta op) - Cross product with hyper operator, eg <a b> X~ <y z> == <ay az by bz>

=item (filetest op) - check if file is executable by real uid/gid

=back

=head2 C<<< Z >>>

=over

=item (list op) - alias to zip (list op)

=back

=head2 C<<< [\ ] >>>

=over

=item (meta op) - circumfix reduction metaop, applies above reduction to a series of lists made of array slices ranging in length from 1 to the complete length of the original list

=back

=head2 C<<< [] >>>

=over

=item - circumfix operator that creates a reference to an array that holds all values that encompas these brackets

=item (meta op) - circumfix reduction metaop, close to functional "reduce", applies the operator between all elements of an array

=back

=head2 C<<< \ >>>

=over

=item - capture operator, creates a reference to the following structure

=item - escape char, all escape sequences inside quotes and regexes start with it

=back

=head2 C<<< ^ >>>

=over

=item - junctive xor, requires that one value in a list is true

=item - in ranges excludes a limit value, in scalar context see smartmatch, in array context see array creating operators;

=item (twigil) - for autogenerated positional parameters of a block, position results from alphabetical order of all $^-Variables

=item (regex Metachar) - start of the string

=back

=head2 C<<< ^^ >>>

=over

=item - logical xor, combines expressions, returns true when only one expression is true, otherwise false

=item (regex Metachar) - start of a line

=back

=head2 C<<< a >>>

=over

=item (quoting adverb) - demands evaluation of array variables, short form of ":array", included in "", qq and <<>>

=item (regex modifier) - no distinction between same chars with or without accent (funny symbols above), short for ":ignoreaccent"

=back

=head2 C<<< aa >>>

=over

=item (regex modifier) - only for substitutions, replacing with chars that have the same accent pattern as the replaced, short for ":sameaccent"

=back

=head2 C<<< abs >>>

=over

=item (scalar num op) - returns numeric absolute value

=back

=head2 C<<< after >>>

=over

=item - comparison operator used by the Order class, true if left should follow right

=back

=head2 C<<< all >>>

=over

=item - junctive AND operator

=back

=head2 C<<< and >>>

=over

=item - logical AND operator

=back

=head2 C<<< andthen >>>

=over

=item - logical AND short circuit operator, transferring $_ from first to second block/command, if first do succeed

=back

=head2 C<<< any >>>

=over

=item - junctive OR operator

=back

=head2 C<<< array >>>

=over

=item (quoting adverb) - demands evaluation of array variables, long form of ":a", included in "", qq and <<>>

=back

=head2 C<<< as >>>

=over

=item - scalar method, converts like sprintf

=back

=head2 C<<< assuming >>>

=over

=item - method of all subroutine reference objects that enables Currying

=back

=head2 C<<< async >>>

=over

=item (block modifier) - allows the interpreter to parallelize the following

=back

=head2 C<<< b >>>

=over

=item (filetest op) - file is a block special file (e.g. Harddisks, CDROMs and RAM areas)

=item (quoting adverb) - forces evaluation of escape sequences, short form of ":backslash", included in "", qq and <<>>

=back

=head2 C<<< backslash >>>

=over

=item (quoting adverb) - forces evaluation of escape sequences, long form of ":b", included in "", qq and <<>>

=back

=head2 C<<< before >>>

=over

=item - comparison operator used by the Order class, true when left should precede right

=back

=head2 C<<< break >>>

=over

=item - leave this when clause now

=back

=head2 C<<< but >>>

=over

=item - alters properties of a variable at run time

=back

=head2 C<<< by >>>

=over

=item - sets interval for the range (..) operator

=back

=head2 C<<< bytes >>>

=over

=item (scalar sring method) - returns number of bytes used (a sort of length)

=item (regex modifier) - searching on byte level, (see also chars, codes, graphs)

=back

=head2 C<<< c >>>

=over

=item (filetest op) - file is a character special file (e.g. terminals modems)

=item (quoting adverb) - forces evaluation of closures (blocks aka { ... }) inside quotes, long form of ":closure", included in "", qq and <<>>

=item (<n>) (regex modifier) - searching from nth (n is an int) position (counting from 0) and then going to the right, short for ":continue"

=back

=head2 C<<< cached >>>

=over

=item (sub trait) - marks memoized routines, or at least memoizable

=back

=head2 C<<< call >>>

=over

=item - execute a subroutine

=back

=head2 C<<< caller >>>

=over

=item - object describing the code from which as routine was invoked

=back

=head2 C<<< callwith >>>

=over

=item - submethode by which one can call a sub with a different signature

=back

=head2 C<<< capitalize >>>

=over

=item - alias to ucirst(lc($_)), makes first char of every word upper case, rest lowercase

=back

=head2 C<<< cat >>>

=over

=item - concatenes strings, synonym for '~' and array method

=back

=head2 C<<< category >>>

=over

=item (grammatical category) - namespace of grammatical categories, in case you want to create a new one with a macro

=back

=head2 C<<< chars >>>

=over

=item (scalar string method) - returns number of characters  

=item (regex modifier) - searching on character level (default), (see also bytes, codes, graphs)

=back

=head2 C<<< chdir >>>

=over

=item - changes the current working directory ($*CWD)

=back

=head2 C<<< chmod >>>

=over

=item - changes access rights of files

=back

=head2 C<<< chomp >>>

=over

=item (scalar method) - returns a string with the last newline (if there is one) removed

=back

=head2 C<<< chop >>>

=over

=item (scalar method) - returns a string with the last character removed

=back

=head2 C<<< chown >>>

=over

=item - changes owner of files

=back

=head2 C<<< circumfix >>>

=over

=item (grammatical category) - operator namespace of ops, that stay after one statement or variable, but do surround a second (like braces in $a[2])

=back

=head2 C<<< class >>>

=over

=item (block modifier) - declares a collection of methods that define an object

=back

=head2 C<<< classify >>>

=over

=item (array op) - special form of map, to sort several arrays

=back

=head2 C<<< close >>>

=over

=item - methode on Filehandle class, ending the connection with a file

=back

=head2 C<<< closure >>>

=over

=item (quoting adverb) - forces evaluation of closures (blocks aka { ... }) inside quotes, long form of ":c", included in "", qq and <<>>

=back

=head2 C<<< cmp >>>

=over

=item (scalar comp op) - compares values textually, gives results -1(lower than), 0 (equal), 1 (greater than), using the Order class

=back

=head2 C<<< code >>>

=over

=item (quoting adverb) - quasi quoting, the commented will be compiles and the AST will be returned as result, see also: quasi

=back

=head2 C<<< codes >>>

=over

=item (regex modifier) - searching on codepoint level (between codepoints), (see also bytes, chars, graphs)

=back

=head2 C<<< comb >>>

=over

=item (array method) - takes another array as parameter and produces cross product of two arrays (like X operator), eg 1,2 X 3,4 == 1,3,1,4,2,3,2,4

=back

=head2 C<<< constant >>>

=over

=item (var trait) - makes so declared var (is constant) a real constant

=back

=head2 C<<< contend >>>

=over

=item (block modifier) - marks a block as atomic, concurrent proceses have to wait

=back

=head2 C<<< continue >>>

=over

=item (flow control) - makes execution in a 'given' also try the following 'when' clauses

=item (<n>) - (regex modifier) - searching from nth (n is an int) position (counting from 0) and then going to the right, short for ":c"

=back

=head2 C<<< d >>>

=over

=item (filetest op) - check if file is a directory

=back

=head2 C<<< default >>>

=over

=item - the clause executed in a given construct if no when clause matched

=back

=head2 C<<< defer >>>

=over

=item (block modifier) -

=back

=head2 C<<< defined >>>

=over

=item - scalar method tests whether a value has been assigned to a variable

=back

=head2 C<<< delete >>>

=over

=item - removes a key and value from a hash

=back

=head2 C<<< dim >>>

=over

=item - array dimensioning

=back

=head2 C<<< div >>>

=over

=item - division, creates fraction objects in Integer context

=back

=head2 C<<< do >>>

=over

=item - executes a block (do once loop)

=back

=head2 C<<< does >>>

=over

=item - checks if an objekt inherits this role

=back

=head2 C<<< double >>>

=over

=item (quoting adverb) - double quoting, "q" with interpolation of variables, alias to "...", qq /.../ and Q :s, :a, :h, :f, :c, :b /.../, long for ":qq"

=back

=head2 C<<< e >>>

=over

=item (filetest op) - tests if file exists

=back

=head2 C<<< elems >>>

=over

=item (array method) - returns number of elements

=back

=head2 C<<< else >>>

=over

=item - introduces the alternative block after an 'if' or 'elsif'

=back

=head2 C<<< elsif >>>

=over

=item - alternative if clause

=back

=head2 C<<< eq >>>

=over

=item - equal, string comparison

=back

=head2 C<<< equiv >>>

=over

=item (sub trait) - defines the relative precedence of an operator as equivalent of an other (given as Parameter)

=back

=head2 C<<< eqv >>>

=over

=item - compares the dynamic state of objects and values, in contrast with static ===

=back

=head2 C<<< err >>>

=over

=item (logical operator) - returns the first defined value from the left

=back

=head2 C<<< ex >>>

=over

=item (regex modifier) - searching at all positions as long as it findes something (with backtracking), short for ":exhaustive"

=back

=head2 C<<< exec >>>

=over

=item (quoting adverb) - quoted string will be executed and replaced with its result, alias to Q :x and qx //

=back

=head2 C<<< exhaustive >>>

=over

=item (regex modifier) - searching at all positions as long as it findes something (with backtracking), long for ":ex"

=back

=head2 C<<< exists >>>

=over

=item - checks for existence of a variable or hash member, scalar method

=back

=head2 C<<< f >>>

=over

=item (filetest op) - file is a plain file (no socket or dir, ...etc.)

=item (quoting adverb) - demands evaluation of functions (subs and methods), that start with "&" and replacing them with the result, long form of ":function", included in "", qq and <<>>

=back

=head2 C<<< false >>>

=over

=item - boolean value aka Bool::False

=back

=head2 C<<< ff >>>

=over

=item - flip flop operator in the style of awk, formerly .. in scalar context

=back

=head2 C<<< fff >>>

=over

=item - flip flop operator in the style of sed, formerly ... in scalar context

=back

=head2 C<<< flip >>>

=over

=item (scalar string op) - revers strings on character level

=back

=head2 C<<< fmt >>>

=over

=item - method on a scalar, takes a format specifier returns a string, simplified sprintf

=back

=head2 C<<< for >>>

=over

=item (block modifier) - iterates over a list

=back

=head2 C<<< function >>>

=over

=item (quoting adverb) - demands evaluation of functions (subs and methods), that start with "&" and replacing them with the result, long form of ":f", included in "", qq and <<>>

=back

=head2 C<<< g >>>

=over

=item (filetest op) - report if file has setgid bit set

=item (regex modifier) - searching for any finding (not just the first), short for :global

=back

=head2 C<<< gather >>>

=over

=item (block modifier) - performs the following block once, returns a list of all values passed by 'take'

=back

=head2 C<<< ge >>>

=over

=item - greater than on equal, string comparison

=back

=head2 C<<< get >>>

=over

=item (handle method) - returns a line (scalar context) or all lines (array context) from that input stream

=back

=head2 C<<< given >>>

=over

=item - case construct puts a value into the context variable for when clauses

=back

=head2 C<<< global >>>

=over

=item (regex modifier) - searching for any finding (not just the first), long for :g

=back

=head2 C<<< goto >>>

=over

=item (flow control) - transfer execution to a defined label

=back

=head2 C<<< grammar >>>

=over

=item - special kind of class to hold regex token and rule definitions

=back

=head2 C<<< graphs >>>

=over

=item (regex modifier) - searching on the level of language-independent graphemes, (see also bytes, chars, codes)

=back

=head2 C<<< group >>>

=over

=item -

=back

=head2 C<<< gt >>>

=over

=item - greater than or equal, string comparison

=back

=head2 C<<< h >>>

=over

=item (quoting adverb) - demands evaluation of hash variables, long form of ":hash", included in "", qq and <<>>

=back

=head2 C<<< handles >>>

=over

=item - delegates execution of a function to another method

=back

=head2 C<<< has >>>

=over

=item - creates an attribute for an object

=back

=head2 C<<< hash >>>

=over

=item - sets hash-list context

=item (quoting adverb) - demands evaluation of hash variables, long form of ":h", included in "", qq and <<>>

=back

=head2 C<<< heredoc >>>

=over

=item (quoting adverb) - defines end marker for the following heredoc, :heredoc is equal to :to

=back

=head2 C<<< i >>>

=over

=item (regex modifier) - uppercase and lowercase variants of a letter are taken as the same letter, short for ":ignorecase" (same as in Perl 5)

=back

=head2 C<<< if >>>

=over

=item (block modifier) - flow control conditional statement or block modifier, executes code only when a condition expression evaluates to true

=back

=head2 C<<< ignoreaccent >>>

=over

=item (regex modifier) - no distinction between same chars with or without accent (funny symbols above), short for ":a"

=back

=head2 C<<< ignorecase >>>

=over

=item (regex modifier) - uppercase and lowercase variants of a letter are taken as the same letter, long for ":i" (same as in Perl 5)

=back

=head2 C<<< ii >>>

=over

=item (regex modifier) - only for substitutions, replacing with chars that have the same case pattern as the replaced, short for ":samecase"

=back

=head2 C<<< index >>>

=over

=item - finds the first occurrence of a substring from a position in a string

=back

=head2 C<<< infix >>>

=over

=item (grammatical category) - operator namespace of ops, that are surrounded by whitespace (\w) between 2 vars or statements ($a + $b)

=back

=head2 C<<< inline >>>

=over

=item (sub trait) -

=back

=head2 C<<< int >>>

=over

=item - extract a whole number value, discarding fractional part

=back

=head2 C<<< invert >>>

=over

=item (hash method) - inverts the key => value relation of pairs and hashes

=back

=head2 C<<< is >>>

=over

=item - bind a traits to a variable

=back

=head2 C<<< join >>>

=over

=item (array method & op) - concatenates list elements into a string, optionally inserting another string between the elements

=back

=head2 C<<< k >>>

=over

=item (filetest op) - report if file has sticky bit set

=back

=head2 C<<< keepall >>>

=over

=item (regex modifier) - forces subrules to memorize everything (even comments)

=back

=head2 C<<< key >>>

=over

=item (pair method) - gives the key part of a pair

=back

=head2 C<<< keys >>>

=over

=item (hash method) - returns list of hash keys

=back

=head2 C<<< kv >>>

=over

=item (hash method) - returns list of key-value pairs

=back

=head2 C<<< l >>>

=over

=item (filetest op) - file is a symbolic link

=back

=head2 C<<< last >>>

=over

=item (flow control) - end the current looping block

=item (array method) - number of final element

=back

=head2 C<<< lc >>>

=over

=item (scalar string op & method) - make string lowercase

=back

=head2 C<<< lcfirst >>>

=over

=item (scalar string op & method) - make first char of a string lowercase

=back

=head2 C<<< le >>>

=over

=item (comparison op) - lower than or equal, string comparison

=back

=head2 C<<< leave >>>

=over

=item (flow control) - exit the current block

=back

=head2 C<<< leg >>>

=over

=item (comparison op) - lower/equal/greater comparator for text

=back

=head2 C<<< let >>>

=over

=item - changes value of a variable temporary, it will be set back if the current block exits unsuccessfully

=back

=head2 C<<< lines >>>

=over

=item (handle method) - returns an iterator over all lines of that input stream, for lazy retrieval

=item (io op) - reads a file and returns content as array of lines

=back

=head2 C<<< loop >>>

=over

=item (block modifier) - general flow control command for repetition

=back

=head2 C<<< looser >>>

=over

=item (sub trait) - defines relative precedence of an operator as lesser than another (given as Parameter)

=back

=head2 C<<< lt >>>

=over

=item (string comparison op) - lower than, string comparison

=back

=head2 C<<< m >>>

=over

=item (regex quoting op) - perform a regex based search in place ( stands for match ), similar to rx (quote regex op)

=back

=head2 C<<< macro >>>

=over

=item - define a routine to alter source code at compile time

=back

=head2 C<<< map >>>

=over

=item - take a list, perform a block on each member, return a list of the results Arraymethode

=back

=head2 C<<< match >>>

=over

=item - compare a string to a regex/token/rule, alias to smartmatch operator (~~)

=back

=head2 C<<< max >>>

=over

=item (list op) - returns the numerically largest value from a given list

=back

=head2 C<<< maybe >>>

=over

=item (block modifier) -

=back

=head2 C<<< method >>>

=over

=item - defines a method in a class

=back

=head2 C<<< min >>>

=over

=item - returns the numerically smallest value from a given list

=back

=head2 C<<< minmax >>>

=over

=item - returns the highest and lowest values from a list, as a 2 item list

=back

=head2 C<<< mm >>>

=over

=item (regex quoting op) - perform a regex based search in place, spaces are just subrule separators, alias to m:sigspace /.../

=back

=head2 C<<< mod >>>

=over

=item (scalar op) - generic modulo operator

=back

=head2 C<<< module >>>

=over

=item (block modifier) - introduces a module name, a package that performs special actions on loading

=back

=head2 C<<< multi >>>

=over

=item (routine modifier) - sub and method overloading modifier to allow multimethod dispatch

=back

=head2 C<<< my >>>

=over

=item (var scope) - makes a variable or routine lexical, therefore exists and is valid only in the current scope (usually a block)

=back

=head2 C<<< new >>>

=over

=item - creates a new object of a class, also name of the automatically called constructor method

=back

=head2 C<<< next >>>

=over

=item (flow control) - looping command to go to the start of the following iteration

=back

=head2 C<<< none >>>

=over

=item - return true when a value is not part of a set, junctive NOT operator

=back

=head2 C<<< not >>>

=over

=item - logical NOT operator, negates truth value, alternative to ! with lower precedence

=back

=head2 C<<< o >>>

=over

=item (filetest op) - tests if file is owned by effective uid

=back

=head2 C<<< of >>>

=over

=item (sub trait) - defines return type, eg subset Month of Int where { 1 <= $^a <= 12 }

=back

=head2 C<<< one >>>

=over

=item - junctive XOR operator

=back

=head2 C<<< only >>>

=over

=item - subroutine modifier, permits only a routine of the same name

=back

=head2 C<<< or >>>

=over

=item - logical or operator

=back

=head2 C<<< orelse >>>

=over

=item - logical OR short circuit operator, transferring an Error code from first to second block/command, if first do not succeed

=back

=head2 C<<< our >>>

=over

=item (var scope) - makes a variable or subroutine name visible in all the current package

=back

=head2 C<<< ov >>>

=over

=item (regex modifier) - searching at all positions just one time (with backtracking), short for ":overlap"

=back

=head2 C<<< overlap >>>

=over

=item (regex modifier) - searching at all positions just one time (with backtracking), long for ":ov"

=back

=head2 C<<< p >>>

=over

=item (filetest op) - file is a named pipe (FIFO), or filehandle is a pipe

=item (<n>) (regex modifier) - searching only on the nth (n is an int) position (counting from 0), short for ":pos"

=back

=head2 C<<< p5=> >>>

=over

=item (array op) - hash constructor, that works like in Perl 5, generates just a list that can converted in hash context to an hash

=back

=head2 C<<< package >>>

=over

=item (block modifier) - defines this Block or File as namespace (almost like in Perl 5), some uses are now better to do with "module" and "class"

=back

=head2 C<<< pair >>>

=over

=item (context op) - force pair context

=back

=head2 C<<< pairs >>>

=over

=item (hash method) - returns all contents as an array or pairs (key,value)

=back

=head2 C<<< panic >>>

=over

=item (regex modifier) - overwriting a possible set :ratchet for all subrules (activates backtracking)

=back

=head2 C<<< parsed >>>

=over

=item (sub trait) - this macro will be parsed once, it is hygienic, but own and later defined rules can't be applied, opposite of "reparsed"

=back

=head2 C<<< perl >>>

=over

=item - evaluates the following string or content of the var on which is called this method, functions with "say" like a better Data::Dumper

=back

=head2 C<<< pop >>>

=over

=item (array op & method) - removes and returns the last element in an array

=back

=head2 C<<< pos >>>

=over

=item (<n>) (regex modifier) - searching only on the nth (n is an int) position (counting from 0), long for ":p"

=back

=head2 C<<< postcircumfix >>>

=over

=item (grammatical category) - operator namespace of ops, that stay after one statement or variable, but do surround a second (like braces in $a[2])

=back

=head2 C<<< postfix >>>

=over

=item (grammatical category) - operator namespace of ops, that stay after a statement or variable (like $a++)

=back

=head2 C<<< prefix >>>

=over

=item (grammatical category) - operator namespace of ops, that stay before a statement or variable (like ++$a)

=back

=head2 C<<< print >>>

=over

=item - sends characters to an output stream without adding a newline, see 'say'

=back

=head2 C<<< printf >>>

=over

=item - formats text and sends it to standard output

=back

=head2 C<<< prompt >>>

=over

=item - reading a line from $*IN formerly STDIN

=back

=head2 C<<< proto >>>

=over

=item - predeclaration of subroutine or method

=back

=head2 C<<< push >>>

=over

=item (array op & method) - adds a list of values to the end of an array

=back

=head2 C<<< q >>>

=over

=item (quoting op) - simple quoting (slashes and '), alias to '...' and Q :q /.../ and Q :single /.../

=item (quoting adverb) - simple quoting (slashes and '), alias to '...' and q /.../, short for ":single"

=back

=head2 C<<< qq >>>

=over

=item (quoting op) - double quoting, "q" with interpolation of variables, alias to "..." and Q :s, :a, :h, :f, :c, :b /.../ and Q :qq // and Q :double //

=item (quoting adverb) - double quoting, "q" with interpolation of variables, alias to "...", qq /.../ and Q :s, :a, :h, :f, :c, :b /.../, short for ":double"

=back

=head2 C<<< quasi >>>

=over

=item (block modifier) - quasi quoting, the commented will be compiles and the AST will be returned as result, see also: code

=back

=head2 C<<< quote >>>

=over

=item (grammatical category) - operator namespace, used to define new quoting ops with a macro

=back

=head2 C<<< quote_mod >>>

=over

=item (grammatical category) - operator namespace, used to define new quoting adverbs

=back

=head2 C<<< quotewords >>>

=over

=item (quoting adverb) - split quoted string on words (on whitespaces) with quote protection (like in shell - '' and "" sourround words), long form of ":quotewords", used in < ... > and << ... >>

=back

=head2 C<<< qw >>>

=over

=item (quoting op) - splits result on words (as in P5), alias to Q :q :w //

=back

=head2 C<<< qx >>>

=over

=item (quoting op) - execute as command and return results (as in P5), alias to Q :x //

=back

=head2 C<<< r >>>

=over

=item (filetest op) - check if file is readable by effective uid/gid

=back

=head2 C<<< rand >>>

=over

=item - generate a floating point random number between 0.0 and 1.0

=back

=head2 C<<< ratchet >>>

=over

=item (regex modifier) - deactivates backtracking, search starts at pos, where last match ended

=back

=head2 C<<< readline >>>

=over

=item - now called 'get', reads from an input stream until the next newline

=back

=head2 C<<< redo >>>

=over

=item - re-starts processing of the current loop

=back

=head2 C<<< regex >>>

=over

=item - (routine type) - a pattern definition (without :ratchet and :sigspace), can be put in a grammar, similar to qr/.../ in Perl 5

=item (quoting adverb) - parse as quoted string as regex

=back

=head2 C<<< reparsed >>>

=over

=item (sub trait) - after parsing this macro, it will be reparsed, so that not hygienic, but its own and later defined rules can be applied, opposite of "parsed"

=back

=head2 C<<< return >>>

=over

=item (flow control) - ends a subroutine and defines the value given to the caller

=back

=head2 C<<< returns >>>

=over

=item - sub trait describing the type of value produced by a function

=back

=head2 C<<< reverse >>>

=over

=item (array method) - returns all the members in the opposite order. Use "flip" to turn a string back to front and "invert" for hashes

=back

=head2 C<<< rindex >>>

=over

=item - finds the last occurrence before a given position, of a substring within a string

=back

=head2 C<<< role >>>

=over

=item - container for methods that can extend a class using does

=back

=head2 C<<< rule >>>

=over

=item - alais for "regex :ratchet :sigspace" in a grammar, see regex, token

=back

=head2 C<<< rw >>>

=over

=item - (Routine Trait) means read/write,

=item (regex modifier) - gives the regex the right to change the string (operand)

=back

=head2 C<<< rx >>>

=over

=item (regex quoting op) - creates anonymous regex, that can me then assigned into a var, alias to Q :regex // and regex (block modificator)

=back

=head2 C<<< s >>>

=over

=item (filetest op) - returns file size in bytes

=item (quoting adverb) - demands evaluation of scalar variables, long form of ":scalar", included in "", qq and <<>>

=item (regex quoting op) - perform a substitution based on rx-matches in place, creates anonymous regex, alias to Q :subst // and subst (block modificator)

=item (regex modifier) - whitespace separates now subregex and don't stand for spaces to look for, short for ":sigspace", mm// is alias to m:sigspace//

=back

=head2 C<<< sameaccent >>>

=over

=item (regex modifier) - only for substitutions, replacing with chars that have the same accent pattern as the replaced, long for ":aa"

=back

=head2 C<<< samecase >>>

=over

=item (regex modifier) - only for substitutions, replacing with chars that have the same case pattern as the replaced, long for ":ii"

=back

=head2 C<<< samespace >>>

=over

=item (regex modifier) - smart space mapping for substitutions, long for ":ss", ss// is alias to s:samespace///, (ss/teh hsa/the has/;)

=back

=head2 C<<< say >>>

=over

=item - a function like print that also appends a newline (\n)

=back

=head2 C<<< scalar >>>

=over

=item (quoting adverb) - demands evaluation of scalar variables, long form of ":s", included in "", qq and <<>>

=back

=head2 C<<< seed >>>

=over

=item - initialize a random number generator, optionally with a value

=back

=head2 C<<< sigil >>>

=over

=item (grammatical category) - word to name the namespace for sigils, used to redifine them or define your own with a macro

=back

=head2 C<<< signature >>>

=over

=item (sub trait) -

=back

=head2 C<<< sigspace >>>

=over

=item (regex modifier) - whitespace separates now subregex and don't stand for spaces to look for, long for for ":s", mm// is alias to m:sigspace//

=back

=head2 C<<< single >>>

=over

=item (quoting adverb) - simple quoting (slashes and '), alias to '...' and q /.../, long for ":q"

=back

=head2 C<<< slurp >>>

=over

=item (io op) - reads a entire file into a string

=back

=head2 C<<< special_variable >>>

=over

=item (grammatical category) - namespace to define and redefine special variables with a macro

=back

=head2 C<<< split >>>

=over

=item - makes an array of substrings from a string and a separator

=back

=head2 C<<< sprintf >>>

=over

=item - like printf but returns the string instead of outputting it

=back

=head2 C<<< ss >>>

=over

=item (regex quoting op) - performs rx based substitution, spaces are just subrule separators, alias to s:samespace/.../.../

=item (regex modifier) - only for for substitution, whitespace separates subregexes like :sigspace, but also in the second part, short for ":samespace", ss// is alias to s:samespace///, (ss/teh hsa/the has/;)

=back

=head2 C<<< state >>>

=over

=item - declares variables known only in the enclosing block, that retain their values between invocations

=back

=head2 C<<< sub >>>

=over

=item (block modifier) - defines a subroutine

=back

=head2 C<<< submethod >>>

=over

=item (block modifier) - defines methods, not inherited by subclasses

=back

=head2 C<<< subset >>>

=over

=item - define a subtype, eg subset Month of Int where { 1 <= $^a <= 12 }

=back

=head2 C<<< subst >>>

=over

=item (quote op) - scalar method to perform substitution, alias to s///

=item (quoting adverb) - parse as substitution

=back

=head2 C<<< substr >>>

=over

=item - the scalar substring function like in Perl 5

=back

=head2 C<<< t >>>

=over

=item (filetest op) - filehandle is opened to a tty (terminal)

=back

=head2 C<<< take >>>

=over

=item - produces a return value in a gather block

=back

=head2 C<<< temp >>>

=over

=item - defines variables as temporary, synonym for the Perl 5 "local"

=back

=head2 C<<< term >>>

=over

=item (grammatical category) - namespace of terms, used to redifine them or make a new with a macro

=back

=head2 C<<< tighter >>>

=over

=item (sub trait) - defines relative precedence of an operator as higher than another (given as Parameter)

=back

=head2 C<<< to >>>

=over

=item (quoting adverb) - defines end marker for the following heredoc, :to is short for :heredoc

=back

=head2 C<<< token >>>

=over

=item - kind of regex :ratchet (no backtracking), part of a grammar

=back

=head2 C<<< tr >>>

=over

=item (quoting op) - transliteration (as in Perl 5), translating some character in a string into others, alias to Q :trans ///

=back

=head2 C<<< trans >>>

=over

=item (quoting adverb) - evals the quoted as transliteration aka tr ///

=back

=head2 C<<< true >>>

=over

=item (term) - converts value into the boolean context, low precedence alternative to "?"

=item - boolean value aka Bool::True

=back

=head2 C<<< trusts >>>

=over

=item - allows a class the acess to otherwised sealed namespaces

=back

=head2 C<<< twigil >>>

=over

=item (grammatical category) - word to name the namespace for twigils, used to redifine them or define your own with a macro

=back

=head2 C<<< u >>>

=over

=item (filetest op) - report if file has setuid bit set

=back

=head2 C<<< uc >>>

=over

=item - make all string chars uppercase

=back

=head2 C<<< ucfirst >>>

=over

=item - make first char of a string uppercase

=back

=head2 C<<< undef >>>

=over

=item - undefined, Perl word for 'empty'

=back

=head2 C<<< unless >>>

=over

=item (block modifier) - flow control modifier, opposite of if, runs block if expression is false

=back

=head2 C<<< until >>>

=over

=item (loop block modifier) - opposite of while, runs block repeatedly is long as expression is false

=back

=head2 C<<< unwrap >>>

=over

=item - remove an enclosing subroutine

=back

=head2 C<<< use >>>

=over

=item - load a module, import definitions, check Perl version

=back

=head2 C<<< value >>>

=over

=item (pair method) - gets value (second) value of a pair

=back

=head2 C<<< values >>>

=over

=item (hash method) - returns an array of just the values

=back

=head2 C<<< w >>>

=over

=item (filetest op) - check if file is writeable by effective uid/gid

=item (quoting adverb) - split quoted string on words (on whitespaces), no quote protection, short form of ":words", used in qw//

=back

=head2 C<<< want >>>

=over

=item - produces a signature object that provides information about the context from which the current routine was called

=back

=head2 C<<< when >>>

=over

=item (block modifier) - executes its code block if a 'given' value smartmatches

=back

=head2 C<<< where >>>

=over

=item - defines subtypes of data, eg subset Month of Int where { 1 <= $^a <= 12 }

=back

=head2 C<<< while >>>

=over

=item (block modifier) - flow control modifier runs block repeatedly as long as en expression is true

=back

=head2 C<<< words >>>

=over

=item (quoting adverb) - split quoted string on words (on whitespaces), no quote protection, long form of ":w", used in qw//

=back

=head2 C<<< wrap >>>

=over

=item - creates enveloping subroutine

=back

=head2 C<<< ww >>>

=over

=item (quoting adverb) - split quoted string on words (on whitespaces) with quote protection (like in shell - '' and "" sourround words), short form of ":quotewords", used in < ... > and << ... >>

=back

=head2 C<<< x >>>

=over

=item (filetest op) - check if file is executable by effective uid/gid

=item (scalar string op) - string replicate operator to single string, eg 'ab' x 3 == 'ababab'

=item (quoting adverb) - quoted string will be executed and replaced with its result, alias to Q :exec and qx //

=item (<n>) (regex modifier) - searching n times (n is an int) with this pattern

=back

=head2 C<<< xor >>>

=over

=item (scalar bool op) - boolean exclusive or operator, only true if only one operand is true

=back

=head2 C<<< xx >>>

=over

=item (scalar string op) - string replicate operator to array, eg 'ab' xx 3 == <ab ab ab>

=back

=head2 C<<< z >>>

=over

=item (filetest op) - tests if file is empty (zero size)

=back

=head2 C<<< zip >>>

=over

=item (list op) - zip operator, joines 2 lists eg 1,2,3,4 Z 8,9 == 1,8,2,9

=back

=head2 C<<< {} >>>

=over

=item - circumfix operator: encloses blocks and creates a coderef, or a hashref when it is identified as a hash or contains a '=>'

=back

=head2 C<<< | >>>

=over

=item (junctive op) - junctive or, requires that a condition is fulfilled

=item (conext op) - dereferences a capture into capture context

=back

=head2 C<<< || >>>

=over

=item - logical or, evaluates sequentially, ends evaluation at the first expression that returns true

=back

=head2 C<<< ~ >>>

=over

=item (conext op), (scalar string op) - forces string context (stringify) and/or concatenate strings, synonym for cat

=back

=head2 C<<< ~& >>>

=over

=item - characterwise and, forces string context

=back

=head2 C<<< ~< >>>

=over

=item - characterwise left shift, forces string context

=back

=head2 C<<< ~> >>>

=over

=item - characterwise right shift, forces string context

=back

=head2 C<<< ~^ >>>

=over

=item - characterwise xor, forces string context

=back

=head2 C<<< ~| >>>

=over

=item - characterwise or, forces string context

=back

=head2 C<<< ~~ >>>

=over

=item - smartmatch operator, compares (almost) all data types

=back

