Perl 6
Perl 6 Index Tablet: Revision 169

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 of all operators, methods, builtins, options (bold) and some technical terms (italic) with short explanations. Each bold term is followed by a link to a condensed summary of its category in appendix B.

  • ! - 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/.../ or Q :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
  • $() (conext op) - forces scalar context, alias to item()
  • $ (regex Metachar) - end of the string
  • $$ (regex Metachar) - end of a line
  • % (sigil) - prefix of hash variables
  • % (numeric op) - gives remainder of a modulo division, forces numeric context
  • %() (conext op) - forces hash context, alias to the hash() function
  • %% (numeric op) - Bool::True if the left is evenly divisible by right value
  • & (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 item context
  • ... (op) - infix operator for list generation
  • ... (yadda op) - term that calls fail (exception), marks unimplemented empty routine bodies
  • / (numeric op) - division, numeric context
  • / (rat composer) - inside round braces (3/7) gives you a rational number that keeps track of its numerator and denominator
  • // (numeric op) - returns the first defined value, similar to orelse
  • \0[<n>] escape sequence - character given in octal (brackets optional)
  • : - 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
  • :b<n> - general radix form for literals, makes a number n in base b (up to 36), for example :2<1000001> is 65
  • : - marks as prefix named parameter in a signature
  • : - (flow control) - endchar of all labels, jou can jump to
  • :: (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)
  • ; - 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)
  • << >> (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
  • < > (quoting op) - circumfix quoting operator for grouping with autoquoting (alias to Q :q :ww /.../ or qw/.../)
  • < > (regex metachar) - embraces an subrule (assertion)
  • = (Op) - assignment, right side is evaluated and assigned to the left
  • <op>= (meta op) - self assignment, left side is one oper and the result is assigned to ($a += 3; equals $a = $a + 3)
  • =:= (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)
  • => (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
  • <var>[] - postcircumfix operator, appended on an array var, returns an array slice with values which indexes was inside the brackets
  • [] - 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
  • [\<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
  • \ - capture generator, creates a reference to the following structure
  • \ - escape char, all escape sequences inside quotes and regexes start with it
  • ^ - 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
  • {} - 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

A

  • :a (quoting adverb) - demands evaluation of array variables, short form of ":array", included in "", qq and <<>>
  • :a (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"
  • 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 (undefined value type) - Perl 6 object (default routine parameter type, excludes junction)
  • any - junctive OR operator
  • arity (routine method) - returns how many parameters this routine requires, take .count if you want have the optional included
  • Array (mutable type) - Perl Array, a series of Scalar value container, or a variable that stores such a list
  • array() (conext op) - forces array context, alias to @()
  • :array (quoting adverb) - demands evaluation of array variables, long form of ":a", included in "", qq and <<>>
  • 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 - 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 class/grammar or replaces them

B

  • :b (filetest op) - file is a block special file (e.g. Harddisks, CDROMs and RAM areas)
  • :b (quoting adverb) - forces evaluation of escape sequences, short form of :backslash, included in "", qq and <<>>
  • \B escape sequence - Match when not on a word boundary
  • \b escape sequence - word boundary
  • :backslash (quoting adverb) _ - forces evaluation of escape sequences, long form of ":b", included in "", qq and <<>>
  • Backtracking - go after an unsuccessful match back to the last successful matching position and check if another alternative part of the regex matches
  • Bag (immutable type) - unordered collection of values that allows duplicates
  • before (comparison op) - generic comparison operator used by the Order class, true when left should precede right
  • BEGIN "(closure trait)"{} - marks a special block or statement, executed at compile time, ASAP, only ever runs once
  • Binding - making two variables share the same content by pointing to same memory location
  • Bit (immutable type) - Perl single bit (allows traits, aliasing, undef, etc.)
  • bless - calling bless on any invocant (but typically a type object) to create a new object with the same class as the invocant
  • 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
  • break (flow control) - leave this when clause block now
  • Buf (mutable type) - Perl buffer (a stringish array of memory locations)
  • but - alters properties of a variable at run time
  • bytes (string method) - returns number of bytes used (a sort of length)
  • :bytes (regex modifier) - searching on byte level, (see also chars, codes, graphs)

C

  • :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
  • 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) - Function call arguments (right-hand side of a binding)
  • cat (array method) - coverts 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
  • 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
  • :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
  • 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
  • :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 (comp op) - compares values textually, gives results -1(lower than), 0 (equal), 1 (greater than), using the Order class
  • 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 aka m//; default pattern is rx/./
  • compile time - the process when Perl converts source code to executable form
  • Complex (immutable type) - Perl complex number
  • 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 - $_ is used by built in Perl functions as an implicit parameter
  • 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")
  • count (routine method) - returns how many parameters this routine takes (including optional), .arity counts just the required
  • 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(&[~]) }
  • Currying - creating a subroutine as a derivate from another with certain parameter to be predefined

D

  • :d (filetest op) - check if file is a directory
  • \D escape sequence - nondigit
  • \d escape sequence - digit
  • 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 - removes a key and value from a hash
  • 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 prints each element of the list to $*ERR (STDERR)
  • dir - returns all files of a given directory, excluding . and .. by default
  • div - division, creates fraction objects in Integer context
  • do - executes a block (do once loop)
  • does - checks if an objekt inherits this role
  • :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

  • :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 (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
  • 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
  • enum - creates a set
  • EnumMap (immutable type) - A mapping of Enums with no duplicate keys
  • 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 (filename, first parameter), 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 //
  • :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 or hash member, scalar method
  • exit - stops all program execution, and returns Int $status (first parameter) to the calling environment
  • export (routine trait) - this routine will be exported my the current module by default

F

  • :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 "&" 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
  • 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
  • FIRST (closure trait) - marks a special block or statement, executed at loop initialization time, before any ENTER
  • flip (string method) - reverses order of characters in strings
  • fmt - method on a scalar, takes a format specifier returns a string, simplified version of sprintf
  • for (loop block modifier) - only iterates over a list
  • :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 <<>>
  • Functional Programming - exclusively function based programming style, strongly supported by Perl 6, considered as a branch of Declarative Programming

G

  • :g (filetest op) - report if file has setgid bit set
  • :g (regex modifier) - searching for any finding (not just the first), short for :global
  • 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 like a file or command line
  • getc (handle method) - reads ones character from a file via file handle
  • 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) - transfer execution to a defined label
  • grammar - special kind of class to hold regex token and rule definitions
  • :graphs (regex modifier) - searching on the level of language-independent graphemes, (see also bytes, chars, codes)
  • 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

H

  • :h (quoting adverb) - demands evaluation of hash variables, long form of ":hash", included in "", qq and <<>>
  • \H (escape sequence) - anything but horizontal whitespace
  • \h (escape sequence) - horizontal whitespace
  • handles - delegates execution of a function to another method
  • HardRoutine - (immutable type) - A routine that is committed to not changing
  • has (scope declarator) - introduces attribute names
  • 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
  • hash (conext op) - enforces hash-list context, alias to %()
  • :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
  • HOW (introspection method) - (reserved for documentation)
  • hyper - forces none-lazy list context, that ignores the order of results (allowes parallel computing)

I

  • :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 code only when a condition expression evaluates to true
  • :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"
  • 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
  • infix (grammatical category) - operator namespace of ops, that are surrounded by whitespace (\w) between 2 vars or statements ($a + $b)
  • 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.)
  • 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)
  • IO (mutable type) - Perl filehandle
  • is - bind a traits to a variable
  • item() (conext op) - forces scalar context, alias to $()
  • Iteration - flow control, repeatedly executing a block
  • Iterator (mutable type) - Perl list

J

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

K

L

  • :l (filetest op) - file is a symbolic link
  • \L[<n>] escape sequence - everything within the brackets is lowercase
  • 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 (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 (closure trait) - marks a special block, executed at every block exit time
  • 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 )
  • lines (path method) - reads a file and returns content as array of lines
  • lines (io op) - returns an lazy iterator over all chomped lines of that input stream
  • list (context op) - almost a no-op, just makes sure that $item (first parameter) can be iterated
  • 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

  • m (regex quoting op) - perform a regex based search in place ( stands for match ), similar to rx (quote regex op)
  • :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 - 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 (mutable type) - Perl match, usually produced by applying a pattern
  • match (string method) - method alias to m//, $str.match( /pat/ ) equals $str ~~ s/pat/;, returns a match object
  • match object - result of an regex operation
  • 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 - 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) - 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 /.../
  • 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

  • \N (escape sequence) - anything but (logical) newline
  • \n (escape sequence) - (logical) newline
  • <n> :nd (regex modifier) - demands the nth finding, has many aliases (:st :rd :th) for correct spelling (:2nd)
  • name (routine method) - returns the name of of a routine, handy when it was stored in a scalar
  • new - creates a new object of a class, 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
  • 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
  • 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

  • :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, 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
  • :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

  • :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 $*OS 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
  • 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 (mutable type) - A single key-to-value association
  • PairSeq (mutable type) - A Seq of Pairs
  • pair (context op) - force pair context
  • pairs (hash method) - returns all contents as an array or pairs (key,value)
  • :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
  • :path (quoting adverb) - quote paths and create path object that know the right format of the current $*OS with Q :path /.../, long for :p
  • perl - evaluates the following string or content of the var on which is called this method, functions with "say" like a better Data::Dumper
  • :Perl5 (regex modifier) - activate old Perl 5 regex rules, alias to :P5
  • pick (array op & method) - select a number of random vaues
  • phaser - Perl 6 term for specially named subblocks withe special runtimes aka closure traits
  • 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
  • pointy block - a block that is given parameters with '->'
  • 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 (like braces in $a[2])
  • postfix (grammatical category) - operator namespace of ops, that stay after a statement or variable (like $a++)
  • PRE (closure trait) - marks a special block, assert precondition, executed at every block entry, before ENTER
  • prefix (grammatical category) - operator namespace of ops, that stay before a statement or variable (like ++$a)
  • print - sends characters to an output stream ($OUT) without adding a newline, similar to say
  • print (handle method) - writes a stream into a file
  • printf - formats text like sprintf and sends it to standard output like print
  • prompt - "print"ing text and reading the answer (a line from $*IN - formerly STDIN)
  • property - metadata set at runtime
  • 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

  • Q (quoting op) - most basic quoting operator, understands a list of adverbial modifier
  • q (quoting op) - simple quoting (slashes and '), alias to '...' and Q :q /.../ and Q :single /.../
  • :q (quoting adverb) - simple quoting (slashes and '), alias to '...' and q /.../, short for ":single"
  • \Q[<n>] escape sequence - all metacharacters within the brackets match as literal characters
  • qp (quoting op) - path quoting, quoted string will be evaled as an file or directory path, alias to Q :p /.../ and Q :path /.../
  • 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 //
  • :qq (quoting adverb) - double quoting, "q" with interpolation of variables, alias to "...", qq /.../ and Q :s, :a, :h, :f, :c, :b /.../, short for ":double"
  • qqx (quoting op) - run as system call and return results (like qx/.../ in Perl 5)
  • 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
  • :quotewords (quoting adverb) - split quoted string into words (on whitespaces) but with quote protection (like in shell - '...' and "..." sourrounded strings are taken as single words), long form of :ww, used in << ... >>
  • qw (quoting op) - splits result on words (as in P5), alias to Q :q :w /.../ or <...>
  • qx (quoting op) - evaluate as Perl term (like eval) and return results (unlike P5), alias to Q :x /.../ or Q :exec /.../

R

  • R<op> (meta op) - reverse operands
  • :R (filetest op) - check if file is readable by real uid/gid
  • :r (filetest op) - check if file is readable by effective uid/gid
  • \R escape sequence - anything but return
  • \r escape sequence - return (CR), as in Perl 5
  • rand - generate a floating point random number between 0.0 and 1.0
  • Range (immutable type) - A pair of ordered endpoints
  • RangeIter (mutable type) - Iterator over a Range
  • Range Operator - written as '..' in scalar context defines set of possible values for smartmatch, in list context makes a list of successive values
  • Rat (immutable type) - Perl rational (exact Real, limited denominator)
  • :ratchet (regex modifier) - deactivates backtracking, search starts at pos, where last match ended
  • <n> :rd (regex modifier) - demands the nth finding, has many aliases (:st :nd :th) for correct spelling (:3rd)
  • 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(&[+])
  • Reference - address of data in memory, often termed a Capture in Perl 6
  • Regex (mutable type) - Perl pattern
  • regex - (routine type) - a pattern definition (without :ratchet and :sigspace), can be put in a grammar, similar to qr/.../ in Perl 5
  • :regex (quoting adverb) - parse as quoted string as regex
  • Regular Expression - in Perl5: pattern matching notation, either regex, token or rule in Perl6
  • 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
  • rename - changes names of files and directories
  • 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
  • rmdir - deletes a directory with given name
  • 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
  • Routine (mutable type) - Base class for all wrappable executable objects
  • rule - alias for "regex :ratchet :sigspace" in a grammar, see regex, token
  • run - executes an external program, and returns control to the caller once the program has exited
  • Runtime - time when software is being used (not compiletime), or software components necessary for that, or length of time to execute
  • rw (routine trait) - marks a subroutine as returning an lvalue
  • rw (parameter trait) - mutable parameter (rw stands for: read write)
  • :rw (regex modifier) - gives the regex the right to change the string (operand)
  • rx (regex quoting op) - creates anonymous regex, that can me then assigned into a var, alias to Q :regex // and regex (block modificator)

S

  • 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 (block modificator)
  • :S (filetest op) - file is a socket
  • :s (filetest op) - file has size greater than 0
  • :s (quoting adverb) - demands evaluation of scalar variables, 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", mm// is alias to m:sigspace//
  • \S escape sequence - anything but whitespace
  • \s escape sequence - any whitespace character (\h or \v or \t)
  • :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/;)
  • 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) - Perl scalar, variable that holds a single value
  • :scalar (quoting adverb) - demands evaluation of scalar variables, long form of ":s", included in "", qq and <<>>
  • Scope - the block of code within which an identifier is usable
  • 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
  • sigil (grammatical category) - word to name the namespace for sigils, used to redifine them or define your own with a macro
  • Signature - (immutable type) - Function parameters (left-hand side of a binding), surrounded by round parentheses
  • 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
  • :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"
  • sleep - attempt to sleep for up to Num $for seconds (with sub-second resolution)
  • slice - part of an array or list
  • slurp (path method) - reads an entire file into a string without a file handle
  • slurpy Array - array parameter that receives all (slurps) all optional subroutine arguments
  • SoftRoutine (mutable type) - A routine that is committed to staying mutable
  • 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/;
  • :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)
  • state (scope declarator) - introduces lexically scoped but persistent names (known only in the enclosing block, but retain their values between invocations)
  • Str (immutable type) - Perl string (finite sequence of Unicode characters)
  • String - series of characters, text
  • Sub (mutable type) - Perl subroutine object
  • sub (block modifier) - defines a subroutine
  • Submethod (mutable type) - Perl subroutine acting like a method
  • submethod (block modifier) - 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
  • 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

T

  • :t (filetest op) - filehandle is opened to a tty (terminal)
  • \T escape sequence - anything but a tab
  • \t escape sequence - tab, not visible character
  • take - can add several item to the list of return values of 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
  • <n> :th (regex modifier) - demands the nth finding, has many aliases (:st :nd :rd) for correct spelling (:2nd)
  • tighter (routine trait) - specifies the precedence of an operator higher than an existing operator
  • :to (quoting adverb) - defines end marker for the following heredoc, :to is short for :heredoc
  • token - kind of regex :ratchet (no backtracking), part of a grammar
  • Topicalizer - every keyword that sets the $_ variable, eg given, for
  • 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 ///
  • Trait - additional property of a variable, defined at compile time, see but
  • :trans (quoting adverb) - evals the quoted as transliteration aka tr ///
  • 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 "?"
  • true - boolean value aka Bool::True
  • trusts - allows a class the acess to otherwised sealed namespaces
  • Twigil - second(ary) Sigil indicating a special property of a variable
  • twigil (grammatical category) - word to name the namespace for twigils, used to redifine them or define your own with a macro

U

  • :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
  • UNDO (closure trait) - marks a special block, executed at every unsuccessful block exit, part of LEAVE queue
  • 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

V

W

  • :W (filetest op) - check if file is writeable by real uid/gid
  • :w (filetest op) - check if file is writeable by effective uid/gid
  • :w (quoting adverb) - split quoted string on words (on whitespaces), no quote protection, short form of ":words", used in qw//
  • \W escape sequence - anything but a word character
  • \w escape sequence - word character (Unicode alphanumeric plus "_")
  • want - produces a signature object that provides information about the context from which the current routine was called
  • warn - makes output via standart error output ($ERR - usually the command line), similar to note, but works more like print, without appending "\n"
  • WHAT (introspection method) - short name of the class that an object belongs to
  • Whatever (undefined value type) - Wildcard (like Any, but subject to do-what-I-mean via multi method dispatch)
  • WHEN (introspection method) - (reserved for events?)
  • WHENCE (introspection method) - autovivification of closures
  • when (block modifier) - executes its code block if a 'given' value smartmatches
  • WHERE (introspection method) - memory address of the object
  • where - defines subtypes of data, eg subset Month of Int where { 1 <= $^a <= 12 }_
  • WHICH (introspection method) - object ID (type)
  • while (loop block modifier) - flow control modifier runs block repeatedly as long as en expression is true
  • WHO (introspection method) - package, that support that object, long name in string context
  • WHY (introspection method) - (reserved for documentation)
  • 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 (quoting adverb) - split quoted string on words (on whitespaces), no quote protection, long form of ":w", used in qw//
  • 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
  • :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

  • 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
  • x (scalar string op) - string replicate operator to single string, eg 'ab' x 3 == 'ababab'
  • X<op> (meta op) - Cross product with hyper operator, eg <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)
  • 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>

Y

  • yadda operator - placeholder for later to be written code, because in empty routines are forbidden, comes in 3 flavours: ..., ??? and !!!

Z

  • Z (list op) - alias to zip (list op) , joines 2 lists eg 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 @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(&[~]) }

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: