Intro    Chapter:   0. History   1. Design   2. Basic   3. Var   4. Op   5. IO   6. Block   7. Sub   8. OOP   9. Regex   10. Meta
Overview   Appendix:   A. Index   B. Grouped   C. Classtree   D. Delta   E. Exciting   F. FAQ   G. Glossary   H. Href 

Short explanations to computer science terms used in the tablets. Contains also links to syntax details, that relate to that term.

Thats why this page is also the ideal entry point for questions like: "Can I do functional programming in Perl 6?" or "What kind of iterators are present and how they are spelled?"

Navigation: 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

»ö« — pure text version of camelia, the Perl 6 mascot


action method — important is a method of a class that is attached to a grammar. Whenever the grammar is used to parse a string and one of the named subexpressions (rules or tokens) are matching, an action method with the same name gets triggered (run).

ALAP (as late as possible) — within a given execution phase - (compile time or run time). opposite of ASAP. [lazy evaluation] means running instructions ALAP.

and — logical operation which results in True only in case both operands (incoming information) are also True, otherwise the result is False, following operator are working under that logic: &, &&, +&, ?&, ~&, all, and andthen —other operations in bool context are: or, xor, not

argument — is a specific value with which a routine is called at a certain time. Not to be confused with parameter.

arity — tells how many operands an operator needs or how many parameter a routine requires. Since all operator are under the hood just methods, these two things end up being the same in Perl 6. You get the arity of a routine with the introspection methods arity (just the required) and count (required and optional). prefix and postfix operator have the arity of one, infix two and the ternary operator has three. — see also: precedence, associativity

array — A numbered set of informations. Any part can be accessed via an index. It's sometimes also called list, even it's not the same in Perl 6. Arrays are one of the primary container types in Perl. See more about them in the var tablet.

ASAP (as soon as possible) — within a given execution phase (compile time or run time). opposite of ALAP

ASCII — short name of an american body that sets standards, but in computer science its often synonym for a particular standard that enumerates 127 character, 95 of them are visible the rest are control character, e.g. "begin a new line", its basically A-Z, a-z, 0-9 and some extra symbols like $, %, &, what you find on your keyboard and what an american typically needs, to enable the rest of the world more fully there is unicode

associativity — If two same operators are in conflict, (which obviously share the same precedence,) the ambiguity gets resolved by the operator's associativity. Power has according to this table right associativity, so 2 ** 2 ** 3 gets resolved to 2 ** (2 ** 3) = 256, which makes your math teacher even happier. — see also: precedence, arity

AST (abstract syntax tree) — tree like data structure, in which source code is transformed, while parsing it

attribute — fundamentally just a [variable] that belongs to an object


backtracking — while searching for a regex pattern in a string, perl has to keep track how far this string matched so far, while comparing letter by letter from left to right. Thus there have to be pointer that wander from left to right. Backtracking refers just to the ability of this pointer to wander back leftward a bit and try another possibility after a part of a pattern didn't match

binding — making two variables share the same content by pointing to same memory location. Done in Perl 6 with := at runtime and with ::= at compile time.

block — syntactically just a piece of code inside curly brackets ({}), when evaluated it becomes an object of the type Block

boolean contextcontext Bool ops


callframe — A place in memory, where all information regarding the execution of a routine is stored.

camelia — name of the the Perl 6 mascot. She supposed to look happy, but can also create tornados in the amazon or something like that. Note that it has still a camel (Perl 5 mascot) inside.

capture — is the name of a type of storage for the arguments of a specific routine call. When variables are used in this call like: chop( $text ), then the capture works like a reference to this variable and provides access to that variable, more ...

class — Named entity with (variables)[#variable] and (routines)[#routine] that serves as a blueprint for the creation of objects. Each of these objects than has its own set of these variables. Classes can inherit these variables and routines from other classes or (roles)[#role] and do even much more. They start with the keyword class.

closure — (routines)[#routine] whose state (content of all local variables) is completely preserved until the next execution, mostly used as a fancy alias for a block

codepoint — A unicode primitive, represented by a specific number, that stands for a slightly varying graphical representation. Since you can create with unicode combined character like an A with an flying pig on top, you would have 2 codepoints but only one grapheme

coderef — [reference] to an executable block of code (routine), in Perl 6 there are just objects representing a routine that can be attributes of other objects

code context — also called callable context


compilation — reading the human written source code and make it an executable (piece of) program

compile time — time when Perl converts source code to executable form (bytecode), is always before run time even if code can be compiled via eval and evalfile when the program is already runnung, to run code at the begin of compile time use BEGIN and CHECK to run at the end of compile time for that unit (mostly the file or the to be evaled string)


complex number

context — Everything and hence every value is in Perl 6 an object of a certain type. If that type doesn't match the demand of the operator it is given to, it will be converted into the demanded. It is said that this operator had forced the context of a certain type. Most important are the item context, array context, numeric context, string context and bool context. A context can also be forced upon a routine, when its return value has to react to the context in which it is called.

context variable — name for $_, which is used by built in Perl functions as an implicit parameter and as memory of the last result

currying — creating a subroutine that calls another with certain parameter to be predefined


declarand — the thing being declared, example: $foo in my $foo;, See also: declarator

declarative programming — programming paradigm that expresses the logic of a computation without describing its control flow

declarator — the command that declares to another entity that it will have a certain property like the "my", "our", "has" ... in a declaration like my $foo;, See also: declarand

delegation — is a techtique where an object has a method that just calls a method of one of its attributes. If the object is a space ship which has a clock it would allow you to call $ship.time instead of $ship.clock.time.

design by contract — programming style in which parameters and return values from routines must meet conditions, in Perl 6 done by signatures

double quoting — means literally to surround text by double quotes which look like this: " ". In opposite to single qouting a lot of characters inside the quotes will not taken literally but mark things to be evaluated. This are variables routines and blocks. The qq operator and the qqx operator do this too. See also: qoute


e (euler number) — about 2.71828182878434, fundamental mathematical constant, important to the functions exp and log, See also: i, pi

encodingASCII UTF-8

escape — means mostly just to put a \ in front of a character inside quotes or regexes. This cancels the special meaning of the character he will be taken literal. But olso the opposite is possible. By escaping an alphabetic letter he can become an otherwise invisible «control char» or an «escape equence» (regex only). «zero-width boundaries» are escaped with the pipe symbol (|), but written only inside angle brackets (< >) that mark subrules, to distinct that from the pipe metacharacter.

evaluation — transforming something, that it gets ready for practical usage - sometimes means that just replacing in a piece of code all variables with there current content, cometimes more like interpreting or compiling something; inside quotes and regexes it has the first meaning, the command eval and evalfile does the second.


expression — a combination of terms and operators like: $a = $b++ - 7;. It can contain values, constants, variables, operators, and functions. Each of the parts has to have a precedence level which decides in which order they are considered.


fat arrow — a name for this operator: =>

file handle — is just a variable through which you can access a file. Technically these are just scalars holding an objects of the type IO which can do much more than just read and write files. They can access directories, pipes the command line (shell) and contain also the test methods. But if its just about getting the file content in on swoop or line wise, slurp and lines do that without a file handle.

functional programming — exclusively function based programming style, strongly supported by Perl 6, considered as a branch of Declarative Programming


grammar — special kind of class

grapheme — a unicode character like a japanese kanji that may be composed out of several codepoints



hash contexthash context

heredocquote Tablet 2


i (imaginary number) — square root of -1, fundamental mathematical constant to build complex number, displayed as 0+1i important to the functions , See also: e, pi






invocantroutine or statement that called the piece of code of issue

scalar context — is a context of the Scalar type, is called in Perl 5 scalar context

iteration — is a repeated executing of a term or block, enforced by iterators. Sometimes its meant as a specific repetition.



junction — a type of value that holds a logical combination of several values,like: (A and B) or C, create them with junctive ops





lexical scope


list contextArray context

list flattening

LOL (List of List)special type of list that can contain other lists, like: [[1,2,3], [4,5,6]] which is a list with 2 elements

lol contextlol context means these sublists (as explained in LOL) will not flattened

LTM (longest token matching) — when searching a pattern with alternatives (sub|substr) the search will continue after finding the pattern 'sub' because of looking for the longest alternative



metaoperator — operator that alters the meaning or expands the scope of another normal operator, a listing of them

metaprogramming — means programms that can change themself.

method — is a [routine] that belongs to a object or a class

MMD (multimethod dispatch) — technique where several routines can have the same name, but different signatures, when the name is called - the suitable routine is seleted via MMD — See also: multi



named capure

named parameterparameter



not — logical operation that changes a true into false and vice versa, following operator working under that logic: !(), not — other operations in bool context are: and, or, xor

numeric contextNum type context



OOP (object oriented orogramming) — programming paradigm (style), that in which functions (routines) are combined with the data the operate on to so called objects.


operator — very short command - containing mostly just a symbol or two (+ or []). Sometimes it's one or a few letters (eq or lt. It can operate on the value in front of him (postfix) or behind him (prefix) or on both (infix). — see also: arity, operator tablet

or — logical operation that has a the result True if at least one of two operands (incoming information) is also True, otherwise the result is False. Following operator working under that logic: |, ||, //, +|, ?|, ~|, any, or orelse, err — other operations in bool context are: and, xor, not


parameter — a slot for an argument that a routine accepts, it usually has a type that sets limits what values are acceptable, there are required parameter, optional parameter, positional parameter and named parameter, sum of all parameters is called signature — example: sub sum (Num $summand1, Num $summand2) { return $summand1 + $summand2 } later: $s = sum(3, 4);, $summand1 and $summand2 are parameter of sum, the values 3 and 4 were the arguments of the specific call of sum


parsetree — hierarchical data representing the logical structure of a program, also called AST


phaser — Perl 6 term for specially named (due a prefix statement) subblocks withe special runtimes aka closure traits — example: BEGIN


pi (π) — about 3.14159265394248, fundamental mathematical constant, ratio of a circle's circumference to its diameter important to the functions, See also: e, i

pipe — connection between 2 processes, move data (mostly only in one direction) without buffering, can also mean just the connection of several commands via ==> and alike

POD (Plain Old Documentation) — a markup language to embeded documentation into Perl source code, has in Perl 6 the ability to store data into special variables like $=pod to be retrieved later, all pod-directives start with a equal sign - more details are written in the basics tablet

pointy block — a block that is given readonly parameters with -> or rw parameters with <->

positional parameterparameter


precedence — If an expression contains several operators like 2 + 3 * 5, Perl will compare the precedence levels (ranks of importance) of the + and * according this table. Because * was higher up, the result becomes 17 (not 25) which is a result your math teacher would also be glad to hear. — see also: associativity.

prefix — simply just something before the main thing. Mostly a letter(s) or a symbol standing befor a word/term/command/...

property — metadata of a variable set at run time

pugs — first usable Perl 6 compiler and interpreter started my audrey tang


quasiquoting — differs a bit from normal quoting operations and has thatswhy its own slang variable $~Quasi. It means to embrace a piece of code that will be compiled but the result will be just the AST.

quote protection — Perl 5 and 6 have the nice qw operator, thats splits a string into words according to the whitespace between words, if you wish a word to contain whitespace, you have to put it in quotes: <<these are "three words">>, this mechanism is called quote protection and is provided by the adverb :ww aka :quotewords which is included in << >>, the adverb :w aka :words which support qw as well as < > don't provide this service, that might also be known to shell users: <these are 'four words'>

quote — Ri quote means to encompass text by character like quoting marks ('' or ""). This text will be processed and then counted as one value of the type Str. The rules (grammar) of this process are stored in $~Quote. See also: single quoting, double quoting heredocs, quasiquoting





reference (or pointer) — address of or pointer to a specific location in the computers memory. Officially there are no references in Perl 6, but there are several container types that can hold other container of values, and there is binding.

regex (regular expression) — in Perl 5 its a pattern matching notation, in Perl 6 a whole rearranged language that does the same, a whole page is dedicated just about that subject

reify — Since lists are per default lazy in Perl 6, it is possible that not all elements are known yet explicitly. However there is an internal pointer up to which element they are known, plus the internal command reify to compute the next element.

role — is just a group of methods and attributes that can be added to or removed from an object or class at any time. Before adding there will be a check at runtime if it overwrites an already existing method or a needed attribute exists. In case of violation an exception will be raised. And a role can't be instantiated nor inherited from like from a class. The keyword role declares the following block to be a role.

routineblock of code callable by name. It can have a signature and a return value. When the routine is compiled it becomes an object of the type SoftRoutine or HardRoutine.

run time — time when execution hits a certain part of the program, after compile time.


scalar — container type for a single value which can be practically every value, incluing any container. Scalar variables have the sigil $.

scalar context — is called in P6 item context.

scope — area within which an identifier (symbol like a variable or routine) is usable. It is normally the current surrounding block or (if there is none) the current file.

set — unordered, finite collection of values without duplicates. Most commonly all elements have the same type. They are declared by the keyword set which creates an object with the container type called Set. set operators are also already included.

sigil — Character that serves as a prefix to categorize the following name (symbol). It stays in front of the actual name without spacing. Most prominent in Perl are the variable sigils: $, **@** and %. They mark the three different variable namespaces (scalar, array and hash) and make interpolation much easier for human and the computer. Perl 6 knows also secondary sigils. For more info see the variable tablet.

signature — definition of a routines parameters (left-hand side of a binding), surrounded by round parentheses

single quoting — means to surround text by single quotes which look like this: ' '. Every sign in this text will be understood literally, except \ and ', which result in ** and '**. The q operator and the qx operator do the same thing. See also: double qouting and qoute.

slang — Perl 6 is a family of languages containing the the main language, quote, regular expressions and more. These sublanguages are called in short slangs. Each slang has a completely independent set of rules (a grammar) which is stored in a slang variable. The slang variables have the twigil ~ like in $~MAIN (main language). You can change or alter them by using the keywords augment and supersede.

slice — part of an array or list

slurpy array — array parameter that receives (slurps) all remaining arguments as one list

smartmatch — The original Perl 6 smartmatch operator looks like this: ~~ and does an universal "compare this with that" dependend on the types of the operands. That can range from simple comparison of two values to applying a regex up to the question if two signatures are compatible - all details in that table.

statement — smallest standalone element of a program that can be executed, divided by terminators. Everything smaller is just a term.

string — in the broadest sense it means just text, a sequence (string) of letters. — Literal strings are expressed via quoting. variables that hold a string have the type Str. There special operators to create strings as well as compare strings. Perl is famous for its regular expressions - pattern for advanced search and replace operations in strings.

string contextcontext Str ops

subroutine — Perl 5-ish term for routine because in Perl 5 there is only the sub command to build a callable block, but in Perl 6 there are much more types hence the name change

subrule — piece of a regular expression that has a name, its findings are stored under that name, some of them were used so often, that their built into to language as predefined subrules

suffix — another word for postfix


symbol table


term — a syntax "atom" like a pair of brackets, an operator or a value(4.32), not to be confused with expression

terminator — character that marks the end of a statement, these are ; and }, more about statements

ternary operator — or conditional operator is the name of this construct: ?? !!. It is a shortcut for if and else which was introduced by the C language as ? : as it is still written in Perl 5. Its useful if every alternative consists only of one term. Its even more handy if you have to feed a variable with the result of the winning alternative (more details). The name comes from the latin word for "one third" (tertiarium), because its the only operator with that arity, hence it has three operands.

test methodtest methods.

topicalizer — every keyword that sets content of the context variable ($_), like given and for

trait — additional property of a variable, defined at compile time, see but, what other languages call trait Perl calls role

transliteration$~Trans, :trans, .trans, tr ///

twigil — second(ary) sigil indicating a special property of a variable, (more details here)


type constraint


unicode — format to save text in, that can contain almost any letter or symbol known to men, not just ASCII, its fully supported by Perl 6, which means any part of a a program might use any character or symbol, strange names that start with UTF are most probably Unicode formats





Virtual Machine (VM) —



xor (eXclusive OR) — logical operation that has a the result True if only one of two operands (incoming information) is also true, otherwise result is False. Following operator working under that logic: ^, ^^, +^, ?^, ~^, one, xor — other operations in bool context are: and, or, not


yadda operator — placeholder for later to be written code inside a routine body. Comes in 3 flavours, depending what should be triggered: ... (fail), ??? (warn) and !!! (die)


Intro    Chapter:   0. History   1. Design   2. Basic   3. Var   4. Op   5. IO   6. Block   7. Sub   8. OOP   9. Regex   10. Meta
Overview   Appendix:   A. Index   B. Grouped   C. Classtree   D. Delta   E. Exciting   F. FAQ   G. Glossary   H. Href