Perl 6 table index

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

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

LICENSE

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

Table index

!

- logical negation, forces binary context;

(twigil) - twigil of private class and object variables

<op> (meta op) - negates (mostly comparsion operators)

!!

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

!!!

(yadda op) - yadda Operator that calles die

" "

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

#

- starts a comment that continues to the end of the line; works even inside regexes as (regex Metachar)

#`( )

- starts a multi line comment that continues to the end of the line or bracket, works with any combination of bracket pairs

$

(sigil) - prefix of scalar vars

(regex Metachar) - end of the string

$$

(regex Metachar) - end of a line

$()

(conext op) - forces scalar context, alias to item()

%

(sigil) - prefix of hash variables

(numeric op) - gives remainder of a modulo division, forces numeric context

%%

(numeric op) - Bool::True if the left is evenly divisible by right value

%()

(conext op) - forces hash context, alias to the hash() function

&

(sigil) - sigil of the callable namespace

- junctive and, requires that all conditions are met

(regex Metachar) - match multiple patterns (AND - connection of patterns)

&&

(logical op) - logical and, conditonal statements, ends evaluation on the first false expression, returns boolean result

' '

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

()

- grouping of values (parameters)

(regex Metachar) - encompass a subregex/submatch

*

(numeric op) - multiplies numbers and forces numeric context on parameters;

(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

- marks as prefix slurpy arrays in signatures

(twigil) - secondary sigil of global variables

**

(numeric op) - raises a number to a power and forces numeric context

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

+

(conext op), (numeric op) - forces numeric context of values and adds results

+&

(numeric op) - bitwise and, numeric context

++

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

+<

(numeric op) - shift left in numeric kontext

+>

(numeric op) - shift right in numeric kontext

+^

(numeric op) - bitwise xor in numeric context

+|

(numeric op) - bitwise or in numeric context

,

- list generating operator

-

(numeric op) - forces numeric context and subtract

--

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

-->

- alternative syntax to type a parameter

->

- assigns a named parameter for a block (pointy block)

.

- secondary sigil for public accessors (getter/setter)

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

..

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

...

(op) - infix operator for list generation

(yadda op) - term that calls fail (exception), marks unimplemented empty routine bodies

/

(numeric op) - division, numeric context

//

(numeric op) - returns the first defined value, similar to orelse

:

- pair generation operator, also known as adverbial syntax

(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>)

(twigil) - for autogenerated named parameters of a block

- marks as prefix named parameter in a signature

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

::

(sigil) - abstraction sigil, name space separator (like in Perl 5)

::=

- binding a value or variable to a variable at compile time

:=

- creates an alias to a variable at runtime (binding)

:O

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

:P5

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

:Perl5

(regex modifier) - activate old Perl 5 regex rules, alias to :P5

:R

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

:S

(filetest op) - file is a socket

:W

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

:X

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

:a

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

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

:aa

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

:array

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

:b

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

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

:b<n>

- general radix form for literals, makes a number n in base b (up to 36), for example :2<1000001> is 65

:backslash

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

:bytes

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

:c

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

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

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

:chars

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

:closure

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

:code

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

:codes

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

:continue

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

:d

(filetest op) - check if file is a directory

:double

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

:e

(filetest op) - tests if file exists

:ex

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

:exec

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

:exhaustive

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

:f

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

(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 <<>>

:function

(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 <<>>

:g

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

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

:global

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

:graphs

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

:h

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

:hash

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

:heredoc

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

:i

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

:ignoreaccent

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

:ignorecase

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

:ignoremark

(regex modifier) - comparing base characters (Unicode non-mark characters) while ignoring any trailing mark characters, long for ":m"

:ii

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

:k

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

:keepall

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

:l

(filetest op) - file is a symbolic link

:m

(regex modifier) - comparing base characters (Unicode non-mark characters) while ignoring any trailing mark characters, short for ":ignoremark"

:mm

(regex modifier) - substitute with chars that has same mark/accent pattern as the matched string, short for ":samemark"

:o

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

:ov

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

:overlap

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

:p

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

(quoting adverb) - quote paths and create path object that know the right format of the current $*OS with Q :p /.../, short for :path

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

:panic

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

:path

(quoting adverb) - quote paths and create path object that know the right format of the current $*OS with Q :path /.../, long for :p

:pos

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

:q

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

:qq

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

:quotewords

(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 << ... >>

:r

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

:ratchet

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

:regex

(quoting adverb) - parse as quoted string as regex

:rw

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

:s

(filetest op) - file has size greater than 0

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

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

:sameaccent

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

:samecase

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

:samemark

(regex modifier) - substitute with chars that has same mark/accent pattern as the matched string, long for ":mm"

:samespace

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

:scalar

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

:sigspace

(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//

:single

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

:ss

(regex modifier) - only for for substitution, whitespace separates subregexes like :sigspace, but also in the second part, short for ":samespace"

:subst

(quoting adverb) - parse as substitution

:t

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

:to

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

:trans

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

:u

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

:w

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

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

:words

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

:ww

(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 << ... >>

:x

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

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

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

;

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

<

- less than, numeric comparison operator

<->

double pointy syntax to assign a rw parameter to a block

<<

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

<<==

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

<<>>>"{link: [Perl 6 IO Tablet] Quote Words} -->

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

<=

- less than or equal, numeric comparison operator

<==

- leftward pointing feed operator

<=>

- numeric less-equal-greater comparison for Order class

<>

(regex metachar) - embraces an subrule (assertion)

<>"{link: [Perl 6 IO Tablet] Quote Words} -->

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

<op>=

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

<var>[]

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

=

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

=:=

(comparison op) - compares binding, if both vars are bound to same memory location

==

(comparison op) - equality of value (numeric)

===

(comparison op) - identity, equality of value and type

==>

(Op) - rightward pointing feed operator

==>>

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

=>

(comparison op) - pair (and hash) constructor, fatarrow

>

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

>=

(comparison op) - greater than or equal, numeric comparison Op

>>

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

?

(conext op) - forces binary context in an expression

- marks as postfix optional parameters in signatures

- quantifier for 0 or 1 occurrence in Regexes

(twigil) - secondary sigil for constant compiler hint variables

?&

- logical op, and combinator, forces binary context

?? !!

(logical op) - ternary or conditional operator

???

(yadda op) - yadda operator that calles warn

?^

- logical xor, forces operands into boolean context

?|

- logical or, forces operands into boolean context

@

(sigil) - sigil of an array

@()

(conext op) - forces (flattened) array context, alias to list() function

Any

(undefined value type) - Perl 6 object (default routine parameter type, excludes junction)

Array

(mutable type) - Perl Array, a series of Scalar value container, or a variable that stores such a list

BEGIN

"(closure trait)"{} - marks a special block or statement, executed at compile time, ASAP, only ever runs once

Bag

(immutable type) - unordered collection of values that allows duplicates

Bit

(immutable type) - Perl single bit (allows traits, aliasing, undef, etc.)

Blob

- (immutable type) - An undifferentiated mass of bits

Block

(immutable type) - Executable objects that have lexical scopes (enclosed by curly braces)

Bool

(immutable type) - Perl boolean

Buf

(mutable type) - Perl buffer (a stringish array of memory locations)

CATCH

(closure trait) - marks a special block to catch exceptions, before LEAVE

CHECK

(closure trait) - marks a special block or statement, executed at compile time, ALAP, only ever runs once

CONTROL

(closure trait) - marks a special block to catch control exceptions (like next/last/return etc), before LEAVE

Capture

(immutable type) - Function call arguments (right-hand side of a binding)

Code

- data typ for code references of any kind

Complex

(immutable type) - Perl complex number

Cool

(undefined value type) - Perl 6 Convenient OO Loopbacks,

Duration

- (immutable type) - The difference between two Instants

END

(closure trait) - marks a special block, executed at run time, ALAP, only ever runs once

ENTER

(closure trait) - marks a special block or statement, executed at every block entry time, repeats on loop blocks

Enum

(immutable type) - An immutable Pair

EnumMap

(immutable type) - A mapping of Enums with no duplicate keys

Exception

(immutable type) - Perl exception, errors or abnormal events interfering with normal execution, which Perl 6 can both generate and handle

FIRST

(closure trait) - marks a special block or statement, executed at loop initialization time, before any ENTER

Failure

(undefined value type) - data type object for an error, thrown by an unhandled exception

FatRat

(immutable type) - Perl rational (unlimited precision in both parts)

HOW

(introspection method) - (reserved for documentation)

HardRoutine

- (immutable type) - A routine that is committed to not changing

Hash

(mutable type) - Perl hash, a two column table of Scalar, values in one column are keys to refer to the values in the other column

INIT

(closure trait) - marks a special block or statement, executed at run time, ASAP, only ever runs once

IO

(mutable type) - Perl filehandle

Inf

- infinity, to generate infinite lazy lists

Instant

- (immutable type) - A point on the continuous atomic timeline

Int

(immutable type) - Perl integer (allows Inf/NaN, arbitrary precision, etc.)

Iterator

(mutable type) - Perl list

KEEP

(closure trait) - marks a special block, executed at every successful block exit, part of LEAVE queue

KeyBag

(mutable type) - KeyHash of UInt (does Bag in list/array context)

KeySet

(mutable type) - KeyHash of Bool (does Set in list/array context)

LAST

(closure trait) - marks a special block, executed at loop termination time, after any LEAVE

LEAVE

(closure trait) - marks a special block, executed at every block exit time

Macro

(mutable type) - Perl compile-time subroutine

Match

(mutable type) - Perl match, usually produced by applying a pattern

Method

(mutable type) - Perl method

Mu

(undefined value type) - most (generic) undefined object

NEXT

(closure trait) - marks a special block, executed at loop continuation time, before any LEAVE

Num

(immutable type) - Perl number (approximate Real, generally via floating point)

POST

(closure trait) - marks a special block, assert postcondition, executed at every block exit, after LEAVE

PRE

(closure trait) - marks a special block, assert precondition, executed at every block entry, before ENTER

Pair

(mutable type) - A single key-to-value association

PairSeq

(mutable type) - A Seq of Pairs

Parcel

- (immutable type) - Arguments in a comma list

Q

(generalized quoting op) - understands a list of adverbs

R

<op> (meta op) - reverse operands

Range

(immutable type) - A pair of ordered endpoints

RangeIter

(mutable type) - Iterator over a Range

Rat

(immutable type) - Perl rational (exact Real, limited denominator)

Regex

(mutable type) - Perl pattern

Routine

(mutable type) - Base class for all wrappable executable objects

S

<op> (meta op) - force sequential (synchronous) evaluation, suppresses any explicit or implicit parallelism

START

(closure trait) - marks a special block or statement, executed on first ever execution, once per closure clone

Scalar

(mutable type) - Perl scalar, variable that holds a single value

Seq

(immutable type) - A list of values (can be generated lazily)

SeqIter

(mutable type) - Iterator over a Seq

Set

(immutable type) - unordered collection of values that allows no duplicates

Signature

- (immutable type) - Function parameters (left-hand side of a binding), surrounded by round parentheses

SoftRoutine

(mutable type) - A routine that is committed to staying mutable

Stash

(mutable type) - A symbol table hash (package, module, class, lexpad, etc)

Str

(immutable type) - Perl string (finite sequence of Unicode characters)

Sub

(mutable type) - Perl subroutine object

Submethod

(mutable type) - Perl subroutine acting like a method

UNDO

(closure trait) - marks a special block, executed at every unsuccessful block exit, part of LEAVE queue

WHAT

(introspection method) - short name of the class that an object belongs to

WHEN

(introspection method) - (reserved for events?)

WHENCE

(introspection method) - autovivification of closures

WHERE

(introspection method) - memory address of the object

WHICH

(introspection method) - object ID (type)

WHO

(introspection method) - package, that support that object, long name in string context

WHY

(introspection method) - (reserved for documentation)

Whatever

(undefined value type) - Wildcard (like Any, but subject to do-what-I-mean via multi method dispatch)

X

(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

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

Z

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

<op> (meta op) - joines the values from same position of 2 lists with following operator and produces in that manner a new list

[\<op>]

(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

[]

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

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

\

- capture generator, creates a reference to the following structure

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

\0[<n>]

escape sequence - character given in octal (brackets optional)

\B

escape sequence - Match when not on a word boundary

\C[<n>]

escape sequence - any character except the bracketed named or control character

\D

escape sequence - nondigit

\E

escape sequence - anything but an escape character

\F

escape sequence - anything but form feed

\H

(escape sequence) - anything but horizontal whitespace

\L[<n>]

escape sequence - everything within the brackets is lowercase

\N

escape sequence - anything but (logical) newline

\Q[<n>]

escape sequence - all metacharacters within the brackets match as literal characters

\R

escape sequence - anything but return

\S

escape sequence - anything but whitespace

\T

escape sequence - anything but a tab

\U[<n>]

escape sequence - everything within the brackets is uppercase

\V

escape sequence - anything but vertical whitespace

\W

escape sequence - anything but a word character

\X[<n>]

escape sequence - anything but the character given in hexadecimal (brackets optional)

\b

escape sequence - word boundary

\c[<n>]

escape sequence - named character or control character

\d

escape sequence - digit

\e

escape sequence - escape character

\f

escape sequence - form feed

\h

(escape sequence) - horizontal whitespace

\n

escape sequence - (logical) newline

\r

escape sequence - return (CR), as in Perl 5

\s

escape sequence - any whitespace character (\h or \v or \t)

\t

escape sequence - tab, not visible character

\v

escape sequence - vertical whitespace

\w

escape sequence - word character (Unicode alphanumeric plus "_")

\x[<n>]

escape sequence - character given in hexadecimal (brackets optional)

^

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

- upto operator, ^$limit expands to 0 ..^ +$limit range

- in range definitions, it excludes a limit value, in scalar context see smartmatch

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

(regex Metachar) - start of the string

^^

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

(regex Metachar) - start of a line

abs

(numeric op) - returns numeric absolute value

after

(comparison op) - generic comparison operator used by the Order class, true if left should follow right

all

- junctive AND operator

and

- logical AND operator

andthen

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

anon

(scope declarator) - introduces names that aren't to be stored anywhere (anonymous)

any

- junctive OR operator

array()

(conext op) - forces array context, alias to @()

as

(string method) - converts like sprintf

(routine trait) - inner type constraint that a routine imposes on its return value

assoc

(routine trait) - specifies the associativity of an operator explicitly

assuming

- method of all subroutine reference objects that enables Currying

async

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

augment

(scope declarator) - adds definitions to an existing name, inserts new methods and attributes into a class/grammar or replaces them

before

(comparison op) - generic comparison operator used by the Order class, true when left should precede right

break

(flow control) - leave this when clause block now

but

- alters properties of a variable at run time

bytes

(string method) - returns number of bytes used (a sort of length)

cached

(routine trait) - marks a subroutine as being memoized

call

- execute a subroutine

caller

- object describing the code from which as routine was invoked

callwith

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

capitalize

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

cat

(array method) - coverts values of a list into string context and joines them like with '~', alias to .join('')

category

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

char

(num method) - convert number into charakter according a character table, reverse of ord

chars

(string method) - returns number of characters

chdir

- changes the current working directory ($*CWD)

chmod

- changes access rights of files

chomp

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

chop

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

chown

- changes owner of files

circumfix

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

class

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

classify

(array method) - special form of map, to classify input values; the return value of the closure determines, under which key the value appears in the resulting hash

close

(filehandle method) - releasing the connection to a file via a file handler

cmp

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

comb

(string method) - $str.comb(/pattern/) equals $str ~~ m:g/pattern/, except it returns the list of findings, not a match object like .match aka m//; default pattern is rx/./

constant

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

contend

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

continue

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

copy

(parameter trait) - read-writable copy of the original argument ("pass-by-value")

cross

(list method) - alias to X operator: @a X @b = (@a; @b).cross

crosswith

(list method) - alias to X metaoperator: @a X~ @b = (@a; @b).crosswith(&[~]) = (@a; @b).cross.slice.map { .reduce(&[~]) }

default

(block modifier) - following block will be executed if no when clause in surrounding block matched

defer

(block modifier) -

defined

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

delete

- removes a key and value from a hash

die

- stop the program now and print a message on $*ERR

dim

- array dimensioning

div

- division, creates fraction objects in Integer context

do

- executes a block (do once loop)

does

- checks if an objekt inherits this role

dynamic

(parameter trait) - parameter is an "environmental" variable, a lexical in the dynamic scope

each

- variant of all() that promises to do things in order, is Positional/Iterable

eager

- forces eager evaluation (now), default for scalars

elems

(array method) - returns number of elements

else

(block modifier) - introduces the alternative block after an 'if' or 'elsif'

elsif

(block modifier) - alternative if clause

enum

- creates a set

eq

- equal, string comparison

equiv

(routine trait) - specifies the precedence of an operator same as an existing operator

eqv

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

err

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

eval

- just evaluates a string as a program and returns result and maybe error message in @!, second optional parameter defines a parser grammar which should understand the string

evalfile

- behaves like, and replaces Perl 5 do EXPR, with optional $lang support

exists

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

exit

- stops all program execution, and returns Int $status (first parameter) to the calling environment

fail

- a return call (end this routine) that throws an exception

false

- boolean value aka Bool::False

ff

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

fff

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

flip

(string method) - reverses order of characters in strings

fmt

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

for

(loop block modifier) - only iterates over a list

gather

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

ge

(comparison op) - greater than on equal, string comparison

get

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

given

(block modifier) - case construct puts a value into the context variable for when clauses

goto

(flow control) - transfer execution to a defined label

grammar

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

grep

(array op & method) - gives all values of an array that pass a filters condition

gt

(comparison op) - greater than or equal, string comparison, Bool::True if alphabetically ordered the right comes before the left

handles

- delegates execution of a function to another method

has

(scope declarator) - introduces attribute names

hash

(conext op) - enforces hash-list context, alias to %()

hyper

- forces none-lazy list context, that ignores the order of results (allowes parallel computing)

if

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

index

(string method) - finds the first occurrence of a substring in a string and returns the numerical position, opposite or rindex

infix

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

inline

(sub trait) -

int

- extract a whole number value, discarding fractional part

invert

(hash op & method) - inverts the key => value relation of a pair or a series of pairs (hash)

is

- bind a traits to a variable

item()

(conext op) - forces scalar context, alias to $()

join

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

key

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

keys

(hash method) - returns list of hash keys

kv

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

last

(flow control) - exit the current looping block

(array method) - number of final element

lazy

- forces lazy evaluation (as late as possible)

lc

(string op & method) - make string lowercase

lcfirst

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

le

(comparison op) - lower than or equal, string comparison (see lt, gt, ge)

leave

(flow control) - exit the current block with a return value

leg

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

let

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

lines

(string method) - returns a chomped list of lines (chunks of character separated by \n) containing a string, $str.lines($limit) equals $input.comb( / ^^ \N* /, $limit )

(path method) - reads a file and returns content as array of lines

(io op) - returns an lazy iterator over all chomped lines of that input stream

lol

(conext op) - forces list of list context on a value, meaning a list which values are not contextualized further (can be lists themthelves), opposite of a flattened list

loop

(loop block modifier) - general flow control command for repetition

looser

(routine trait) - specifies the precedence of an operator lower than an existing operator

lt

(comparison op) - lower than, string comparison, Bool::True if alphabetically ordered the left comes before the right

m

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

macro

- define a routine to alter source code at compile time

map

(array op & method) - take a list, perform a block on each member, return a list of the results Arraymethode

match

(string method) - method alias to m//, $str.match( /pat/ ) equals $str ~~ s/pat/;, returns a match object

max

(array op & method) - returns the numerically largest value from a given list

maybe

(block modifier) -

method

- defines a method (inheritable routine) in a class

min

(array op & method) - returns the numerically smallest value from a given list

minmax

(array op & method) - returns the highest and lowest values from a list, as a 2 item list

mod

(numeric op) - generic modulo operator

module

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

ms

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

multi

routine modifier - marks routines with can have sibling with same name but different signature, when called, the one with matching sig is executed (multimethod dispatch)

my

(scope declarator) - introduces lexically scoped names, which exists only in the current scope (usually a block)

new

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

next

(flow control) - start the the next following loop iteration

none

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

normalize

- (string method) - normalize (repair) Unicode (UTF) string

not

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

of

(routine trait) - inner type constraint that a routine imposes on its return value, eg subset Month of Int where { 1 <= $^a <= 12 }

one

- junctive XOR operator

only

routine modifier - permits only one routine of the same name in this block

open

(filehandle method) - establishes a connection to a file via a file handler

or

- logical OR operator

ord

(string method) - convert charakter into number according a character table, reverse of char

orelse

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

our

(scope declarator) - introduces package - scoped names

pack

- repackage values into or from a condensed format

package

(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"

pair

(context op) - force pair context

pairs

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

parcel

(parameter trait) - raw reference, will not be contextualized

parsed

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

perl

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

pick

(array op & method) - select a number of random vaues

(array method) - selects randomly elements from this list, optional parameter says how many

pop

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

postcircumfix

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

postfix

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

prefix

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

print

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

printf

- formats text and sends it to standard output

prompt

- "print"ing text and reading the answer (a line from $*IN - formerly STDIN)

proto

routine modifier - fallback for multi, if no multi routines signature matches the callers, a proto with same name is executed

push

(array op & method) - appends a list of values to the end of an array

q

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

qq

(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 //

quasi

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

quote

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

quote_mod

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

qw

(quoting op) - splits result on words (as in P5), alias to Q :q :w /.../ or <...>

qx

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

rand

- generate a floating point random number between 0.0 and 1.0

readline

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

readonly

(parameter trait) - immutable parameter

redo

(flow control) - re-starts processing of the current loop turn

reduce

(list method) - alias to [ ] metaoperator: [+] @a = @a.reduce(&[+])

regex

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

reparsed

(routine 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"

repeat

(loop block modifier) - initial command for while or until loops that have their condtion at the end

return

(flow control) - leaves a subroutine and sets the return value

returns

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

reverse

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

rindex

(string method) - finds the last occurrence of a substring in a string and returns the numerical position, opposite or index

role

- container for methods that can extend a class using does

roll

(array method) - selects $n (first parameter) values from an array, duplication can occur (like rolling dice)

roundrobin

(array method) - kind of zip that ignores empty values: roundrobin([1..3],[1,2],[1]) = 1,1,1,2,2,3

rule

- alias for "regex :ratchet :sigspace" in a grammar, see regex, token

rw

(routine trait) - marks a subroutine as returning an lvalue

(parameter trait) - mutable parameter (rw stands for: read write)

rx

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

s

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

say

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

seed

- initialize a random number generator, optionally with a value

sigil

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

signature

(routine trait) - signature of a subroutine. Normally declared implicitly, by providing a parameter list and/or return type

sleep

- Attempt to sleep for up to Num $for seconds (with sub-second resolution)

slurp

(path method) - reads an entire file into a string without a file handle

special_variable

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

splice

(array op & method) - remove on $pos (first parameter) $n (second - optional) values and replace them with values (third - optional)

split

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

sprintf

- inserts formated values out of variables into a string like printf, but returns the string instead of outputting it

ss

(regex quoting op) - performs rx based substitution, spaces are just subrule separators, alias to s:samespace/.../.../, e.g.: ss/teh hsa/the has/;

state

(scope declarator) - introduces lexically scoped but persistent names (known only in the enclosing block, but retain their values between invocations)

sub

(block modifier) - defines a subroutine

submethod

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

subset

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

subst

(string method) - method alias to s///, $str.subst( /pat/, "replacement" ) equals $str ~~ s/pat/"replacement/;

substr

(string method) - the scalar substring function like in Perl 5

supersede

(scope declarator) - replaces definitions of an existing name, e.g. methods and attributes of a class/grammar

take

- produces a return value in a gather block

temp

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

term

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

tighter

(routine trait) - specifies the precedence of an operator higher than an existing operator

token

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

touch

(filehandle method) - update timestamps on a file

tr

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

trans

(string method) - method name for tr/// operation, $str.trans( %mapping ) equals $str ~~ tr/%mapping.sort.keys/%mapping.sort.values/;

triangle

(list method) - alias to [\ ] metaoperator: [\+] @a = @a.triangle(&[+])

true

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

- boolean value aka Bool::True

trusts

- allows a class the acess to otherwised sealed namespaces

twigil

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

uc

- make all string chars uppercase

ucfirst

- make first char of a string uppercase

unless

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

until

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

unwrap

- remove an enclosing subroutine

use

- load a module, import definitions, check Perl version

value

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

values

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

want

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

warn

- prints a message on $*ERR

when

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

where

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

while

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

will do

(routine trait) - block of code executed when the subroutine is called. Normally declared implicitly, by providing a block after the subroutine's signature definition

words

(string method) - returns a list of words (chunks of alphanumeric character) containing a string, $input.words($limit) equals $input.comb( / \S+ /, $limit )

wrap

- creates enveloping subroutine

x

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

xor

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

xx

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

zip

(array op & method) - zip operator, joines 2 lists, alias to Z operator @a Z @b = (@a; @b).zip

zipwith

(list method) - alias to Z metaoperator: @a Z~ @b = (@a; @b).zipwith(&[~]) = (@a; @b).zip.slice.map { .reduce(&[~]) }

{}

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

|

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

(regex Metachar) - match alternate patterns (OR - connection of patterns)

|()

(conext op) - flatten capture object into arglist

||

(logical op) - logical or, evaluates sequentially, ends evaluation at the first expression that returns true

||()

(conext op) - flatten capture object into semicolon list

~

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

~&

- characterwise and, forces string context

~<

- characterwise left shift, forces string context

~>

- characterwise right shift, forces string context

~^

- characterwise xor, forces string context

~|

- characterwise or, forces string context

~~

- smartmatch operator, compares (almost) all variable and data types