Perl 6
Perl 6 Index Tablet: Revision 449

Overview - Chapter: 0:History, 1:Design, 2:Basics, 3:Var, 4:Op, 5:IO, 6:{}, 7:Sub, 8:OOP, 9:Rx, 10:Meta
Intro - Appendices: A:Index, B:Tables, C:Cook, D:Delta, E:Best of, F:Links


A | B | C | D | E | F | G | H | I | J | K | L | M | N | O | P | Q | R | S | T | U | V | W | X | Y | Z

This index contains an alphanumeric sorted list (sorted without prefixes like colon, slash, sigil or twigil) of all operators, methods, builtins, options, modifier and special variables (bold) and some technical terms (italic) with short explanations. Each bold term is followed by a link (in round brackets) to a condensed summary listing of its category in appendix B. Sometimes are added placeholder for parameter in angle brackets. <n> stands for a integer number, <f> is a floating point number, <s> string, <var> any variable, <op> any operator and <p> for a regex pattern.

Before alpha chars (a-z) come the other in ASCII order: !"# $%& '(* +,- ./0 :;< =>? @[\ ^_{ |~

  • :a (quoting adverb) - demands evaluation of array variables that starting with the @-sigil, short form of :array, included in "...", qq/.../ and <<...>>
  • abs (numeric op) - returns numeric absolute value
  • after (generic comparison) - generic comparison operator used by the Order class, True if left should follow right
  • <?after <p>> (predefined subrule) - zero-width lookbehind
  • all (junctive op) - junctive AND operator, True if all conditions (elements of a following list) are fulfilled, see also: &
  • <alnum> (predefined subrule) - a single alphanumeric character, equivalent to <+alpha +digit>
  • <alpha> (predefined subrule) - a single alphabetic character
  • and (logical op) - short circuit logical AND, returns the last defined value (from left to right), low precedence version of &&, similar to andthen
  • andthen (logical op) - logical AND short circuit operator, transferring $_ from first to second block/expression, if first do succeed, see also: orelse
  • anon (scope declarator) - introduces names that aren't to be stored anywhere (anonymous)
  • Any (undefined value type) - Perl 6 object (default routine parameter type, excludes junction)
  • any (junctive op) - junctive OR operator, True when any one condition (of a following list) is true in bool context, see also: |
  • $*ARGFILES (special var) - magic command-line input handle, was ARGV in P5
  • @*ARGS (special var) - arguments (parameter) to a program (script), formerly @ARGV
  • arity (routine method) - returns how many parameters this routine requires, .count includes also the optional
  • Array (mutable type) - Perl Array, a series of Scalar value container, or a variable that stores such a list
  • :array (quoting adverb) - demands evaluation of array variables that starting with the @-sigil, long form of :a, included in "...", qq/.../ and <<...>>
  • as (parameter trait) - data coming through that parameter will be coerced to the type following as
  • as (routine trait) - inner type constraint that a routine imposes on its return value
  • assoc (routine trait) - specifies the associativity of an operator explicitly
  • assuming {assuming}- method of all subroutine reference objects that enables Currying
  • AST - (abstract syntax tree), tree like data structure, in which source code is transformed, before running the programm
  • 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 grammar or replaces them, see also: supersede
  • :c (filetest op) - file is a character special file (e.g. terminals modems)
  • :c (quoting adverb) - forces evaluation of closures (blocks aka {...}) inside quotes, long form of :closure, included in "...", qq/.../ and <<...>>
  • :c(<n>) (regex modifier) - searching from nth (n is an int) position (counting from 0) and then going to the right, short for ":continue"
  • \C[<n>] (escape sequence) - any character except the bracketed named or control character
  • \c[<n>] (escape sequence) - named character or control character
  • |c (escape sequence) - codepoint boundary, zero width space between two unicode codepoints, see also: |g and |w
  • cached (routine trait) - marks a subroutine as being memoized
  • call - execute a subroutine
  • caller - object describing the code from which as routine was invoked
  • callframe - returns an object that describes a particular call frame as described by a list of matchers
  • 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
  • Capture (immutable type) - type holding arguments for a routine call (right-hand side of a binding)
  • cat (array method) - converts values of a list into string context and joines them like with '~', alias to .join('')
  • CATCH (closure trait) - marks a special block to catch exceptions, before LEAVE
  • categorize (array method) - special form of map to classify a list values (values - optional second parameter), with a closure (mapper - first parameter); the return value of the closure determines, under which key the value appears in the resulting hash, unlike classify the return value of the mapper can be listref to put the value in several categories or Nil to reject the value for categorisation
  • category (grammatical category) - grammatical category of all grammatical categories (metacategory), useful in case you want to create a new one with a macro
  • ceiling - lowest integer not less than $x (only parameter)
  • char (num method) - convert number into charakter according a character table, reverse of ord
  • chars (string method) - returns number of characters of a string, was length in Perl 5
  • :chars (regex modifier) - searching on character level (default), see also: :bytes, codes, graphs
  • chdir - changes the current working directory ($*CWD)
  • CHECK (closure trait) - marks a special block or statement, executed at compile time, ALAP, only ever runs once
  • chmod - changes access rights of files
  • chomp (string method) - returns a string with the last newline (if there is one) removed (from only parameter)
  • chop (string method) - returns a string with the last character removed (from only parameter)
  • chown - changes owner of files
  • chroot - change root directory on POSIX systems
  • circumfix (grammatical category) - operator namespace of two parted ops that surround the statement, op or variable they affect, most prominent example may be the double quotes
  • class (block modifier) - declares a collection of methods that define an object
  • $?CLASS (special var) - current class object
  • ::?CLASS (special var) - name of the current class
  • classify (array method) - special form of map to classify a list values (values - optional second parameter), with a closure (mapper - first parameter); the return value of the closure determines, under which key the value appears in the resulting hash, classify { chr $_ }, 97..99 returns {"a" => [97], "b" => [98], "c" => [99] } , values are always listrefs (see also categorize)
  • close (filehandle method) - releasing the connection to a file via a file handler
  • :closure (quoting adverb) - forces evaluation of closures (blocks aka {...}) inside quotes, long form of :c, included in "...", qq/.../ and <<...>>
  • closure - routines whose state (content of all local variables) is completely preserved until the next execution
  • cmp (generic comparison) - general infix sort comparator, result is Order::Increase (numerically -1) if before is True - Order::Same (numerically 0) if eqv - Order::Decrease (numerically 1) if after, see also: leg and <=>)
  • <cntrl> (predefined subrule) - a not visible character that is aimed to control the console output
  • Code - data typ for code references of any kind
  • :code (quoting adverb) - quasi quoting, the commented will be compiles and the AST will be returned as result, see also: quasi
  • coderef - reference (pointer) to an executable block of code (routine)
  • :codes (regex modifier) - searching on codepoint level (between codepoints), (see also bytes, chars, graphs)
  • comb (string method) - $str.comb(/pattern/) equals $str ~~ m:g/pattern/ , except it returns the list of findings, not a match object like .match(rx/.../) aka m/.../, default pattern is rx/./
  • @=COMMENT (special var) - all the comment blocks in the file
  • compile time - the process when Perl converts source code to executable form
  • Complex (immutable type) - Perl complex number
  • conjugate - convert complex number into real (Numeric type), see also abs
  • 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
  • context - when executing a function or operator Perl considers the expression from which the call was to return a scalar or other kind of result
  • context variable - name for $_, which is used by built in Perl functions as an implicit parameter and as memory of the last result
  • continue (flow control) - makes execution in a 'given' also try the following 'when' clauses
  • :continue(<n>) - (regex modifier) - searching from nth (n is an int) position (counting from 0) and then going to the right, short for :c
  • CONTROL (closure trait) - marks a special block to catch control exceptions (like next/last/return etc), before LEAVE
  • Cool (undefined value type) - Perl 6 Convenient OO Loopbacks,
  • copy (parameter trait) - read-writable copy of the original argument ("pass-by-value")
  • cos (numeric op) - cosine, trigonometric function, takes angle in radians; see also to-radians, sin, tan
  • count (routine method) - returns how many parameters this routine takes (including optional), .arity counts just the required
  • cross (list method) - alias to X operator - example: @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(&[~]) }
  • currying - creating a subroutine as a derivate from another with certain parameter to be predefined
  • $*CWD (special var) - current working directory ("Str"{link:str type})
  • :d (filetest op) - check if file is a directory
  • \D (escape sequence) - a single nondigit character
  • \d (escape sequence) - a single digit character
  • $=data (special var) - handle for the data block (=begin data ... =end data)
  • @=data (special var) - lines of the data block (=begin data ... =end data)
  • decode (Buf method) - transforms raw binary UTF (Buf) into readable UTF Text (Str)
  • default (block modifier) - following block will be executed if no when clause in surrounding block matched
  • Declarative Programming - programming paradigm that expresses the logic of a computation without describing its control flow
  • defer (block modifier) -
  • defined - scalar method tests whether a value has been assigned to a variable
  • delete (array method) - removes all values of which indices are passed
  • delete (hash method){link: [Perl 6 Variable Tablet]Hash Methods} - removes all pairs of which keys are passed
  • denominator (rat method) - returns the denominator of a rational number (value type Rat and FatRat)
  • Design by Contract - programming style in which parameters and return values from routines must meet conditions; A signature is considered contract in Perl 6
  • die - throws a fatal Exception, the default exception handler print's each element of the list to $*ERR
  • <digit> (predefined subrule) - single (decimal) digit char aka \d
  • dir - returns all files of a given directory, excluding . and .. by default
  • $*DISTRO (special var) - running OS distribution, you might want to use $DISTRO.name, see also: $*KERNEL and $*VM
  • $?DISTRO (special var) - OS distribution the program was compiled for, see also: $?KERNEL and $*VM
  • div - integer division
  • do - executes a block (do once loop)
  • does - checks if an objekt inherits a role (parameter)
  • dotty (grammatical category) -
  • :double (quoting adverb) - double quoting, q with interpolation of variables, alias to "...", qq /.../ and Q :s :a :h :f :c :b /.../, long for :qq
  • Duration - (immutable type) - The difference between two Instants
  • dynamic (parameter trait) - parameter is an "environmental" variable, a lexical in the dynamic scope
  • :e (filetest op) - tests if file exists
  • \E (escape sequence) - anything but an escape character
  • \e (escape sequence) - escape character
  • each - variant of all() that promises to do things in order, is Positional/Iterable
  • eager - forces eager evaluation (compute all values now), default for scalars - not for lists
  • $*EGID (special var) - effective global ID of the running process ($*PID) owner, was @) and $EGID in Perl 5
  • elems (array op & method) - number of elements (values), end
  • elems (hash op & method) - number of pairs
  • else (block modifier) - introduces the alternative block after an if or elsif, that is executed, when conditions of all alternatives resulted in false (see also default)
  • elsif (block modifier) - alternative if clause
  • encode (Buf method) - transforms readable UTF Text (Str) into raw binary UTF (Buf)
  • END (closure trait) - marks a special block, executed at run time, ALAP, only ever runs once
  • end (array op & method) - last index of that list, see also: elems
  • 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
  • enum - enum takes a list of keys or pairs and adds values to any keys that are not already part of a pair (one more than the previous key had) - example: %hash = enum <<:Mon(1) Tue Wed Thu Fri Sat Sun>>;
  • EnumMap (immutable type) - A mapping of Enums with no duplicate keys
  • %*ENV (special var) - environment variables (of the shell), was %ENV in P5
  • eq (comparison op) - infix operator, proves equality in forced string context as does = in numeric context
  • equiv (routine trait) - specifies the precedence of an operator same as an existing operator
  • eqv (comparison op) - infix operator, compares the dynamic state of objects and values, in contrast with static =
  • err (logical op) - short circuit defined or, returns the first defined value from the left, short circuit or,low precedence version of //
  • $*ERR (special var) - standard error output (command line mostly), STDERR in Perl 5
  • $*EUID (special var) - effective user ID of the running process ($*PID) owner, was @> and $EUID in Perl 5
  • 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
  • evaluation - reading the human written source code and make it an executable (piece of) program
  • evalfile - evals a file like "do" did in Perl 5, with optional second parameter, which is a grammar that can parse that file
  • :ex (regex modifier) - searching at all positions as long as it findes something (with backtracking), short for :exhaustive
  • Exception (immutable type) - Perl exception, errors or abnormal events interfering with normal execution, which Perl 6 can both generate and handle
  • :exec (quoting adverb) - quoted string will be evaluated as Perl code (like eval) replaced with its result, alias to Q :x and qx/.../
  • $*EXECUTABLE_NAME (special var) - name of the main scripts file name, was $0 in Perl 5
  • :exhaustive (regex modifier) - searching at all positions as long as it findes something (with backtracking), long for :ex
  • exists - checks for existence of a variable, array or hash member, scalar method
  • exit (flow control) - stops all program execution, and returns Int $status (first parameter) to the calling environment
  • exp - exponentiate, alias method to: $base (first parameter) ** $exponent (second parameter - defaults to e)
  • export (routine trait) - this routine will be exported by the current module by default
  • :f (filetest op) - file is a plain file (no socket or dir, ...etc.)
  • :f (quoting adverb) - demands evaluation of functions (subs and methods), that start with the &-sigil and replacing them with the result, long form of :function , included in "...", qq/.../ and <<...>>
  • \F (escape sequence) - anything but form feed
  • \f (escape sequence) - form feed
  • fail - causes the routine to return an unthrown exception, if use fatal is in effect where the routine was called from, it throws the exception
  • Failure (undefined value type) - data type object for an error, thrown by an unhandled exception
  • False - boolean value aka Bool::False, 0 in numeric context, '' (empty) in string context
  • FatRat (immutable type) - Perl rational (unlimited precision in both parts)
  • 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
  • $?FILE (special var) - current filename of source file
  • FIRST (closure trait) - marks a special block or statement, executed at loop initialization time, before any ENTER
  • first (array op & method) - returns first value of a list that passes a condition (first paramter); the condition is a closure that takes one value at a time (as $_ or $^a); works like grep - example : first {$_ %% 2}, 1..5; # returns 2
  • flat (context op) - forces flat list context, opposite of lol - example: ([2,3],[4,5]).flat or flat([2,3],[4,5]) results in: [2..5]
  • flip (string method) - reverses order of characters in string, see also: reverse and invert
  • fmt (formater) - variable method for simple printf - like formating, takes a format specifier and returns a string, format specifier accepts only 1 value placeholder, in case of a hash max. 2; second, optional parameter is delimiter between values or pairs (in case of a hash);
  • for (loop block modifier) - only iterates over a list and sets $_ for each iteration
  • fork - creates a copy of the current process and returns in the original process a Proc object of the child (0 in num context) and in the child a proc object of the original (process ID in num context)
  • from-radians - convert from radians to $base (second parameter), opposite of to-radians
  • :function (quoting adverb) - demands evaluation of functions (subs and methods), that start with the &-sigil and replacing them with the result, long form of :f , included in "...", qq/.../ and <<...>>
  • Functional Programming - exclusively function based programming style, strongly supported by Perl 6, considered as a branch of Declarative Programming
  • :g (filetest op) - report if file has setgid bit set
  • :g (regex modifier) - searching for any finding (not just the first), short for :global
  • |g (escape sequence) - grapheme boundary, zero width space between two unicode graphemes, see also: |c and |w
  • gcd (numeric infix op) - greatest common divisor (see also: lcm)
  • gather (block modifier) - performs the following block once, returns a list of all values passed by take
  • ge (infix string comparison) - greater than or equal, see also gt and le
  • get (handle method) - returns a line (item context) or all lines (list context) from that input stream like a file or command line
  • getc (handle method) - reads one character from a file via file handle
  • getlogin - returns the username of the account running the program, maybe less secure as getpwuid
  • gethost - establish a connection to a net host and retrieve information
  • $*GID (special var) - real global ID of the running process ($*PID) owner, was @( and $GID in Perl 5
  • given (block modifier) - case construct puts a value into the context variable for when clauses
  • :global (regex modifier) - searching for any finding (not just the first), long for :g
  • goto (flow control) - continue execution on a defined label (with "name:")
  • grab (hash method) - random selection of hash keys, weighted by its related values, grabbing a key decrements its value (local copy) by one (deleting key when it goes to 0), see also pick ans roll
  • grabpair (hash method) - random selection <n> (only parameter) of hash pairs, (each pair only once) , see also pick ans roll
  • grammar - special kind of class with methods that execute regex, token and rule
  • $?GRAMMAR (special var) - grammar of the currently used language (mostly $~MAIN)
  • <graph> (predefined subrule) - a "graphical" character
  • :graphs (regex modifier) - searching on the level of language-independent graphemes, (see also bytes, chars, codes)
  • grep (array op & method) - returns all values of an array that pass a filter condition (first parameter); the condition is a closure that takes one value at a time (as $_ or $^a); see also first - example : grep {$_ %% 2}, 1..5; # returns 2 4
  • gt (string comparison) - infix operator, greater than or equal, True if alphabetically ordered the right comes before the left (see also lt, leg and <)
  • :i (regex modifier) - uppercase and lowercase variants of a letter are taken as the same letter, short for :ignorecase (same as in Perl 5)
  • if (block modifier) - flow control conditional statement or block modifier, executes following code block only when a condition expression evaluates to True (see also elsif and else)
  • :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
  • import - just import definitions from an already loaded module (see use and need)
  • $*IN (special var) - standard input (command line mostly), see also $*OUT
  • @*INC (special var) - include pathes (but not for standard library modules), formerly @INC
  • index (string method) - finds the first occurrence of a substring in a string and returns the numerical position, opposite or rindex
  • Inf - infinity, to generate infinite lazy lists, does same as *
  • infix (grammatical category) - namespace of symbols that stay between two statements, that become their parameters - example: $a + $b # is same as $a.&infix:<+>($b)
  • infix_circumfix_meta_operator (grammatical category) - internal namespace of metaoperator that circumfix other operator but stay infix (between) two terms (mostly lists) - example (the arrows): _ @a <<+<< @b_
  • infix_postfix_meta_operator (grammatical category) - internal namespace of metaoperator that postfix other operator but stay infix (between) two terms - example (equal sign): _ $a += 5_
  • infix_prefix_meta_operator (grammatical category) - internal namespace of metaoperator that prefix (precedes) other operator but stay infix (between) two terms - example (exclamation mark): _ 4 != 5_
  • INIT (closure trait) - marks a special block or statement, executed at run time, ASAP, only ever runs once
  • inline (sub trait) -
  • Instant - (immutable type) - a point on the continuous atomic timeline
  • Int (immutable type) - Perl integer (allows Inf/NaN, arbitrary precision, etc.); use it as method to convert into a int like the Perl 5 "int"
  • invert (hash op & method) - inverts the key => value relation of a pair or a series of pairs (hash), returning a Pair list, see also reverse and flip
  • IO (mutable type) - Perl filehandle
  • is - bind a traits to a variable
  • item() (context op) - forces scalar context, alias to $()
  • Iteration - flow control, repeatedly executing a block
  • Iterator (mutable type) - Perl list
  • join (array method) - concatenates list elements into a string, optionally inserting another string between the elements - example: join("-", 1..5) # returns '1-2-3-4-5' - or (1..5).join("-")
  • :l (filetest op) - file is a symbolic link
  • \L[<n>] (escape sequence) - everything within the brackets is lowercase
  • $*LANG (special var) - LANG variable from %*ENV that defines what human language is used
  • LAST (closure trait) - marks a special block, executed at loop termination time, after any LEAVE
  • last (flow control) - exit the current looping block
  • last (array method) - number of final element
  • lazy - forces lazy evaluation (calculate values as late as possible), default for lists - not scalars
  • lc (string op & method) - make string lowercase
  • lcfirst (string op & method) - make first char of a string lowercase
  • lcm (numeric infix op) - least common multiple, see also: gcd
  • le (string comparison) - infix operator, result is True if left side is lower than or equal than the right, see also: lt, gt and ge
  • LEAVE (closure trait) - marks a special block, executed at every block exit time
  • leave (flow control) - exit the current block with a return value
  • leg (string comparison) - general infix sort comparison operator in string context, leg stands for lower/equal/greater, cmp is the more general form, <=> does same in numerical context, was cmp in P5
  • let - changes value of a variable temporary, it will be set back if the current block exits unsuccessfully
  • $?LINE (special var) - current line number
  • lines (string & iomethod) - returns a chomped list of lines (chunks of character separated by \n) containing a string - example: $str.lines($limit) equals $input.comb( / ^^ \N* /, $limit ) , works also on file handles
  • list() (context op) - almost a no-op, just makes sure that $item (first parameter) can be iterated, alias to @(), see also flat and lol
  • list context -
  • log - logarithm of $x (first parameter) to the $base (second optional parameter - default is e, together also known as ln )
  • log10 - logarithm to the base of 10, also known as lg on calculators
  • lol (context op) - forces list of list context on a value, meaning a list which values are not contextualized further (can be lists themthelves), opposite of flat
  • longest token matching - (short LTM) when searching a pattern with alternatives (sub|substr) the search will continue after finding the pattern 'sub' because of looking for the longest alternative
  • loop (loop block modifier) - general flow control command for repetition
  • looser (routine trait) - specifies the precedence of an operator lower than an existing operator
  • <lower> (predefined subrule) - a single lowercase character
  • lt (string comparison) - infix operator, lower than, True if alphabetically ordered the left comes before the right
  • m// (regex quoting op) - perform a regex based search in place (m stands for match ), similar to match-method
  • :m (regex modifier) - comparing base characters (Unicode non-mark characters) while ignoring any trailing mark characters, short for :ignoremark
  • Macro (mutable type) - Perl compile-time subroutine
  • macro (routine type) - define a routine to alter source code at compile time
  • $~MAIN (special var) - current grammar of main language, tells the parser the rules of parsing Perl
  • map (array op & method) - take a list, perform a block on each member, return a list of the results - example: say map { chr $_ }, 66..69 (is "B C D E") or say map { chr $_ }, 66..69
  • Match (mutable type) - Perl match object, usually produced by applying a pattern of regular expression to a string
  • match (string method) - method alias to m/.../, $str.match( /<p>/ ) equals $str ~~ m/<p>/;, returns a match object that end up also in $/
  • max (array op & method) - returns the numerically largest value from a given list
  • maybe (block modifier) -
  • metaoperator - alters the meaning of other operators
  • Method (mutable type) - Perl method
  • method (routine type) - 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
  • :mm (regex modifier) - substitute with chars that has same mark/accent pattern as the matched string, short for :samemark
  • mkdir - creates a directory with given name
  • mod (numeric op) - integer modulo operator; wordy alias to % - example: 5 mod 4 = 1;
  • module (block modifier) - introduces a module name, a package that performs special actions on loading
  • &?MODULE (special var) - reference to the current module
  • ms// (regex quoting op) - perform a regex based search in place, spaces are just subrule separators, alias to m:s/.../ or m :sigspace /.../
  • Mu (undefined value type) - most (generic) undefined object
  • 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)
  • \N (escape sequence) - anything but (logical) newline
  • \n (escape sequence) - (logical) newline
  • <n> :nd (regex modifier) - demands the nth finding (:2nd), has many aliases (:st :rd :th) for correct spelling
  • name (routine method) - returns the name of of a routine, handy when it was stored in a scalar
  • need - just load a module, without import definitions (see use and import)
  • new - creates a new object of a class(as in most other languages), also name of the automatically called constructor method
  • NEXT (closure trait) - marks a special block, executed at loop continuation time, before any leave
  • next (flow control) - start the the next following loop iteration
  • nextsame - get from the dispatcher the next candidate with the same signature, similar to javas SUPER
  • Nil (undefined value type) - unlike undef in Perl 5 it really means no value here - example: @a = Nil, Nil; # array has zero elements
  • none (junctive op) - return True when a value is not part of a set, junctive NOT operator
  • normalize - (string method) - normalize (repair) Unicode (UTF) string
  • not (logical op) - logical NOT operator, returns False if value is positive or True if negates, low precedence version of !
  • note - makes output via command line ($ERR) like warn, but appends a newline (\n) like say
  • Num (immutable type) - Perl number (approximate Real, generally via floating point)
  • numerator (rat method) - returns the numerator of a rational number (value type Rat and FatRat)
  • :O (filetest op) - tests if file is owned by real uid
  • :o (filetest op) - tests if file is owned by effective uid
  • Object Oriented Programming - programming paradigm (style), that arranges data and functions that belong together into so called objects
  • of (routine trait) - inner type constraint that a routine imposes on its return value - example: subset Month of Int where { 1 <= $^a <= 12 }
  • one (junctive op) - junctive XOR operator, True if only one expression (of a following list) is true in bool context, see also: |
  • only routine modifier - permits only one routine of the same name in this block
  • open (path method) - establishes a connection to a file via a file path name file handler
  • or (logical op) - short circuit OR, evaluates sequentially, ends evaluation at the first expression that returns True, low precedence version of ||, similar to orelse
  • ord (string method) - convert charakter into number according a character table, reverse of char
  • orelse (logical op) - logical OR short circuit operator, transferring an Error code from first to second block/command, if first do not succeed, similar to //, see also andthen
  • our (scope declarator) - introduces package - scoped names for variables and routines
  • $*OUT (special var) - standard output (command line mostly), see also $*IN
  • :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
  • :p (quoting adverb) - quote paths and create path object that know the right format of the current $*KERNEL with Q :p /.../, short for :path
  • :p(<n>) (regex modifier) - searching only on the nth (n is an int) position (counting from 0), short for :pos
  • :P5 (regex modifier) - activate old Perl 5 regex rules, alias to :Perl5
  • $~P5Regex (special var) - current grammar of the Perl 5 compatible regular expression language
  • 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
  • &?PACKAGE (special var) - reference to the current package
  • package_declarator (grammatical category) - internal namespace for - example: package, module, class
  • Pair (mutable type) - A single key-to-value association
  • pair (context op) - force pair context
  • pairs (hash method) - returns all contents as an array or pairs (key,value)
  • PairSeq (mutable type) - A Seq of Pairs
  • :panic (regex modifier) - overwriting a possible set :ratchet for all subrules (activates backtracking)
  • parameter - value passed to a method or subroutine, mostly as part of the signature
  • Parcel - (immutable type) - Arguments in a comma list
  • 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
  • parsetree - hierarchical data representing the logical structure of a program, also called AST
  • :path (quoting adverb) - quote paths and create path object that know the right format of the current $*KERNEL with Q :path /.../, long for :p
  • perl (formater) - transforms data structure into Perl 6 source syntax; use eval onto that string and you get the data structure again; bit like Data::Dump
  • $*PERL (special var) - Perl version running under, was $] and $^V in Perl 5
  • $?PERL (special var) - Perl version compiled for
  • :Perl5 (regex modifier) - activate old Perl 5 regex rules, alias to :P5
  • pick (array op & method) - select a number (first parameter) of random vaues (without duplication), take roll to enable duplication
  • $*PID (special var) - ID of the running process, was $$ and $PID in Perl 5
  • phaser - Perl 6 term for specially named subblocks withe special runtimes aka closure traits - example: BEGIN
  • pick (array method) - selects randomly elements from this list, optional parameter says how many
  • pipe - connection between 2 processes, move data (mostly only in one direction) without buffering
  • POD - Plain Old Documentation, a markup language to be embedded into Perl source code, has in Perl 6 ability to store data to be retrieved later
  • $=pod (special var) - surrounding POD object
  • pointy block - a block that is given parameters with ->
  • polar - magnitude or angle corresponding to the complex number(only parameter); the magnitude is non-negative, and the angle in the range {-π ..^ π}}
  • pop (array op & method) - removes and returns the last element in an array
  • :pos(<n>) (regex modifier) - searching only on the nth (n is an int) position (counting from 0), long for :p
  • POST (closure trait) - marks a special block, assert postcondition, executed at every block exit, after LEAVE
  • postcircumfix (grammatical category) - operator namespace of ops, that stay after one statement or variable, but do surround a second - example(square brackets): $a[2]
  • postfix (grammatical category) - operator namespace of ops, that stay after a statement or variable (like $a++)
  • postfix_prefix_meta_operator (grammatical category) - internal namespace of metaoperator that prefix (precedes) other operator but stay postfix (after) another term - example (greater as): @a >>++
  • PRE (closure trait) - marks a special block, assert precondition, executed at every block entry, before ENTER
  • pred (sequence traversion) - returns the predecessor of $x (only parameter), alias to -- operator, see also succ
  • prefix (grammatical category) - operator namespace of ops, that stay before a statement or variable - example: ++$a
  • prefix_circumfix_meta_operator (grammatical category) - internal namespace of metaoperator that circumfix (surrounds) other operator but stay prefix (before) another term - example (square brackets): [+] @a # sums up all elements of @a
  • prefix_postfix_meta_operator (grammatical category) - internal namespace of metaoperator that postfix other operator but stay prefix (before) another term - example (greater as): ++<< @a
  • pretty (formater) - format data structures, optimized for human interpretation
  • print - sends characters to an output stream ($*OUT) without adding a newline, similar to say
  • print (handle method) - writes a stream into a file
  • <print> (predefined subrule) - a single printable character
  • printf - formats text like sprintf and sends it to standard output like print
  • <prior> - standard grammar's rule for whatever the prior successful regex matched
  • prompt - print - ing text and reading the answer (a line from $*IN - formerly STDIN)
  • property - metadata of a variable set at runtime
  • proto (routine modifier) - fallback for multi, if no multi routines signature matches the callers, a proto with same name is executed
  • <punct> (predefined subrule) - a single punctuation character
  • push (array op & method) - appends a list of values to the end of an array (see also pop)
  • push (hash op & method) - inserts a list of pairs in a Hash; if a key already exists, it will point to an array of both values
  • S<op> (meta op) - force sequential (synchronous) evaluation, suppresses any explicit or implicit parallelism
  • s/// (regex quoting op) - perform a substitution based on rx-matches in place, creates anonymous regex, alias to Q :subst /.../.../ and .subst() (string method)
  • :S (filetest op) - file is a socket
  • :s (filetest op) - file has size greater than 0 (zero)
  • :s (quoting adverb) - demands evaluation of scalar variables that start with the $-sigil, long form of :scalar, included in "...", qq/.../ and <<...>>
  • :s (regex modifier) - whitespace separates now subregex and don't stand for spaces to look for, short for :sigspace, ms/.../ is alias to m:sigspace/.../
  • \S (escape sequence) - anything but whitespace
  • \s (escape sequence) - any whitespace character, horizontal ( \h ) and vertical ( \v )
  • <?same> (predefined subrule) - match the zero-width space between two identical chars
  • :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/.../.../ - example: ss/teh hsa/the has/;
  • say - makes output via command line ($*OUT) like print, but appends a newline (\n)
  • say (handle method) - writes a stream into a file and appends \n
  • Scalar (mutable type) - object to hold a Perl scalar, a variable for a single value
  • :scalar (quoting adverb) - demands evaluation of scalar variables that start with the $-sigil, long form of :s, included in "...", qq/.../ and <<...>>
  • scope - the block of code within which an identifier is usable
  • scope_declarator (grammatical category) - internal namespace for scope declarators - example: my, our, has, state
  • seed - initialize a random number generator, optionally with a 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
  • set (array op & method) - creates a Set
  • sigil (grammatical category) - word to name the namespace for sigils, used to redifine them or define your own with a macro
  • sigil - character that serves as a prefix to categorize the following name, most prominent in Perl are the variable sigils: $, @ and %
  • sign - 1 when $x (only parameter) > 0, -1 if < 0, 0 when = 0, undefined when undefined
  • Signature - (immutable type) - object type to hold all information a signature like parameter types and values, return type, etc.
  • signature (routine method) - returns a capture object with the signature of this routine
  • signature (routine trait) - signature of a subroutine. Normally declared implicitly, by providing a parameter list and/or return type
  • signature - function parameters (left-hand side of a binding), surrounded by round parentheses
  • :sigspace (regex modifier) - whitespace separates now subregex and don't stand for spaces to look for, long for for :s, ms/.../ is alias to m:sigspace/.../
  • sin (numeric op) - sine, trigonometric function, takes angle in radian; see also to-radians, cos, tan
  • :single (quoting adverb) - simple quoting (slashes and '), alias to '...' and q/.../, long for :q
  • sleep - attempt to sleep for up to Num $for seconds (with sub-second resolution)
  • slice - part of an array or list
  • slang - sublanguages of Perl 6, their grammar is mostly stored in special variables with the twigil ~, such as $~Regex or $~MAIN (main language); you can change or alter them with this keyword by using the augment or supersede command
  • slurp (path|file handle method) - reads an entire file into a string without a file handle
  • slurpy array - array parameter that receives all (slurps) all optional subroutine arguments
  • so (op) - converts value into the boolean context, low precedence alternative to ?
  • SoftRoutine (mutable type) - A routine that is committed to staying mutable
  • <space> (predefined subrule) - single white space char aka \s
  • 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 (formater) - inserts formated values out of variables into a string like printf, but returns the string instead of outputting it
  • sqrt - square root of $n (Num - first and only parameter)
  • ss/// (regex quoting op) - performs rx based substitution, spaces are just subrule separators, alias to s:ss/.../.../, e.g.: ss/teh hsa/the has/;
  • :ss (regex modifier) - only for for substitution, whitespace separates subregexes like :sigspace, but also in the second part, short for :samespace
  • <n> :st (regex modifier) - demands the nth finding, has many aliases (:nd :rd :th) for correct spelling (:1st)
  • START (closure trait) - marks a special block or statement, executed on first ever execution, once per closure clone
  • Stash (mutable type) - A symbol table hash (package, module, class, lexpad, etc)
  • stat (filetest op) - available information about a file or link (call stat :link as former lstat)
  • state (scope declarator) - introduces lexically scoped but persistent names (known only in the enclosing block, but retain their values between invocations)
  • statement_control (grammatical category) - internal namespace for block modifier like conditionals or loops that stay in front of it
  • statement_mod_cond (grammatical category) - internal namespace for words that come after a statement and handle if the statement will be executed - example : $a++ if $a > 3
  • statement_mod_loop (grammatical category) - internal namespace for special group of block modifier that turn the block into a loop - example : loop, repeat, for
  • statement_prefix (grammatical category) - internal namespace for block modifier - example : do
  • Str (immutable type) - Perl string (finite sequence of Unicode characters)
  • Sub (mutable type) - Perl subroutine object
  • sub (routine type) - defines a subroutine, a block callable by name
  • Submethod (mutable type) - Perl subroutine acting like a method
  • submethod (routine type) - defines methods, not inherited by subclasses
  • subroutine - block of code callable by name
  • subset - define a subtype, eg subset Month of Int where { 1 <= $^a <= 12 }
  • :subst (quoting adverb) - parse as substitution regex, Q :subst /.../.../ is alias to s/.../.../
  • subst (string method) - method alias to "s/.../.../"{link:s op}, $str.subst( /pat/, "replacement" ) equals $str ~~ s/pat/"replacement/;
  • substr (string method) - the scalar substring function like in Perl 5
  • succ (sequence traversion) - returns the successor of $x (only parameter), alias to ++ operator (see pred)
  • supersede (scope declarator) - replaces definitions of an existing name, e.g. methods and attributes of a class or grammar, see also: augment
  • :u (filetest op) - report if file has setuid bit set
  • \U[<n>] (escape sequence) - everything within the brackets is uppercase
  • uc - make all string chars uppercase
  • ucfirst - make first char of a string uppercase
  • $*UID (special var) - real user ID of the running process ($*PID) owner (user), was @< and $UID in Perl 5
  • UNDO (closure trait) - marks a special block, executed at every unsuccessful block exit, part of LEAVE queue
  • uniq (list method) - only unique elements of a list
  • 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 (see wrap)
  • <upper> (predefined subrule) - a single uppercase character
  • uri - returns IO::Streamable descendant for accessing content of that URI (only pramameter typed Str)
  • $?USAGE (special var) - default usage message generated at compile time
  • use - load a module, check Perl version, import definitions (see need and import)
  • X (list op) - Cross product of two arrays, alias of cross method - example: 1,2 X 3,4 == 1,3,1,4,2,3,2,4;
  • x (string op) - string replicate operator to single string - example: 'ab' x 3 == 'ababab';
  • X<op> (meta op) - Cross product with hyper operator, alias of crosswith method - example: <a b> X~ <y z> == <ay az by bz>;
  • :X (filetest op) - check if file is executable by real uid/gid
  • :x (filetest op) - check if file is executable by effective uid/gid
  • :x (quoting adverb) - quoted string will be evaluated as Perl code (like eval) and replaced with its result, alias to Q :exec /.../ and qx/.../
  • :x(<n>) (regex modifier) - searching n times (n is an int) with this pattern
  • \X[<n>] (escape sequence) - anything but the character given in hexadecimal (brackets optional)
  • \x[<n>] (escape sequence) - character given in hexadecimal (brackets optional)
  • <xdigit> (predefined subrule) - single hexadecimal digit char
  • xor (logical op) - infix logical eXclusive OR operator (XOR), True if only one side has positive value, returns otherwise left value, low precedence version of ^^
  • xx (infix list op) - replicate a list $n (second operand) times - example: {{ 'ab' xx 3 = <ab ab ab> }}
  • yadda operator - placeholder for later to be written code, because in empty routines are forbidden, comes in 3 flavours: ..., ??? and !!!
  • Z (list op) - alias to zip (list op) , joines 2 lists - example: 1,2,3,4 Z 8,9 == 1,8,2,9
  • Z<op> (meta op) - joines the values from same position of 2 lists with following operator and produces in that manner a new list
  • zip (array op & method) - zip operator, joines 2 lists, alias to Z operator - example: @a Z @b = (@a; @b).zip
  • zipwith (list method) - alias to Z metaoperator - example: @a Z~ @b = (@a; @b).zipwith(&[~]) = (@a; @b).zip.slice.map { .reduce(&[~]) }

A | B | C | D | E | F | G | H | I | J | K | L | M | N | O | P | Q | R | S | T | T | U | V | W | X | Y | Z


Overview - Chapter: 0:History, 1:Design, 2:Basics, 3:Var, 4:Op, 5:IO, 6:{}, 7:Sub, 8:OOP, 9:Rx, 10:Meta
Intro - Appendices: A:Index, B:Tables, C:Cook, D:Delta, E:Best of, F:Links



Upload Files

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

Maximum file size: 50MB

 
 
 
File Name Author Date Uploaded Size

Save Page As

Enter a meaningful and distinctive title for your page.

Page Title:

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

Page Already Exists

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

Save with a different name:

Save the page with the name "XXX"

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

Upload Files

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

 
 
 
Add Tags

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

Tag: 

Suggestions: