Synopsis 99: Glossary
Created: 26 June 2013
Last Modified: 26 Feb 2015
Version: 8This document tries to define many of the terms used within the Perl 6 community. It does not have an "apocalypse" or "exegesis predecessor". It is intended as both a quick introduction to terms used on the "#perl6" "channel" on "freenode", as well as a more permanent, and deeper source of explanations in the context of Perl 6.
If you, as a reader, miss a term in a glossary, just add the term with the explanation. Or if you are not sure what the missing term means, just add a header for the term. Without doubt, someone else more knowledgeable will add the explanation later for you and everybody else.
An abstract "class" defines the "interface" of a class. Its "method"s are left undefined. In Perl 6, abstract classes is one of the related abstractions implemented as "role"s.
An improved version of "grep", written in Perl (http://beyondgrep.com).
Also used by old folks to indicate acknowledgement.
A class used to generate an "AST" from the results of parsing text with a "grammar". The method to attach a generated AST is called "make", to retrieve an AST you can call "made" or "ast". See "Action objects" in S05-regex.
Articles about Perl 6 for every days of December before Christmas. At https://perl6advent.wordpress.com/.
See "adverbial pair".
A generalized form of "pair notation". They all start with the colon, like:
adverbial pair | pair notation
================|==============
:foo<bar> | foo => 'bar'
:foo(bar) | foo => bar
:$foo | foo => $foo
:foo | foo => True
:!foo | foo => FalseAs Far As I Can See.
As Far As I Can Tell.
As Far As I Know.
Away From Keyboard. Logged in, but there's no one looking at the screen.
As Late As Possible
The class from which most things derive, except for "Junction"s. Any is derived from "Mu".
A Junction with "or" semantics.
Application Programming Interface. Ideally, someone using your system or library should be able to do so with knowledge only of the API, but not necessarily knowing anything about the internals or implementation.
A document originally written by "TimToady", in which he processed the initial barrage of RFC's that came out of the Perl community. Now only kept as an historical document for reference. See also "Exegesis" and "Synopsis".
Number of "operand"s expected by an "operator".
Acronym for Abstract Syntax Tree. Used in many places, including "actions", "PAST", and "QAST".
See "CAS".
Per-object storage slot. Other languages call it "Field", "Member", "Slot" or "Property".
Way of deliberately ambiguously expressing "author" or "authority".
"Are you ignorant or apathetic?" - "I don't know, and I don't care."
That part of a discussion on an "IRC" channel that you've missed. If it is not or no longer available in your IRC client, you can go to sites such as http://irc.perl6.org to see what has been logged for you.
Feature of a combinatorial algorithm which goes back one step toward the trunk after failing exploring a branch of the potential solution space. A string match is such an algorithm. Here, backtracking usually means moving back the "cursor". In a non-greedy match, it means moving the cursor forward.
Denote a VM targeted by "Rakudo". Can be "MoarVM", "JVM" or "Parrot".
Spanish for "dancer", The Bailador module (https://github.com/tadzik/Bailador/) is a port of Perl 5's Dancer web framework (http://perldancer.org/).
A non-quoted alphanumeric string. In Perl 6, only allowed at the left of a "fat comma".
Back In A Bit. Only "afk" for a little while.
An operator is binary or of "arity" two if its "category" is "infix" or "postcircumfix".
"Block, Alternatively Statement". Several constructs in Perl 6 expect either a single "statement", or a "block". Thus, a blast:
try { dangerous(); functions() };
# ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Block
try dangerous-function();
# ^^^^^^^^^^^^^^^^^^^^ StatementParticularly cute, because "phaser"s expect blasts.
A source code section delimited by braces and may have an explicit "signature". Used for "control flow" and as "scope". A "return" in a block returns from the enclosing subroutine. A block is a "first class entity" which makes it useful for "functional programming".
"Block, OR Statement". Different way to say "blast".
Boolean type.
Value of type "Bool". Apart the class itself, can be either True or False.
A "context" that forces an expression to give a "boolean" value. The "prefix" "operator"s so, not and their respective higher "precedence" ? and ! forms force a boolean context with ! and not doing a negation. The "predicate" part of a "control flow" "statement" forces a boolean context. A class can define a Bool method to handle the boolean context. For natives, within "MoarVM", it is handled by /MVMBoolificationSpec member of the "STable" structure.
Starting up a system that uses itself to define, build or compile itself, is a practical exercise on solving the chicken and egg problem. This phase is called bootstrap. Documentation about bootstrapping the "6model" of MoarVM
A program that does automatic tasks on one or more "IRC" channel by acting like a regular user (as far as the server is concerned) and performing some tasks that may involve answering to users requests. "camelia", "dalek" and "yoleaux" are bots on the "#perl6" channel.
Operation transforming a native value into an object. The reverse operation is unboxing. The relation between boxed/native should not be confused with "container"/containee.
Be Right Back. Only "afk" for a little while.
Bounded Serialization.
BSON is the binary counterpart to the textual "JSON" data format. Used by Mongodb and supported by the MARTIMM/BSON "project".
The way to report problems to the implementors. For the interpreters themselves, use "RT". It is good practice to include the interpreter "version" in a bug report. A short piece of example code that demonstrates the bug without requiring any further set-up is usually very well received, too - see also "golfing" For the user packages hosted on "github", you can report issues.
A bundle is a special "module" that directs "Panda" to install a list of modules. See also: "Task::Star".
Bytecode is to a "Virtual Machine" what "machine code" is to a CPU but, unlike machine code, is portable. From "source code" "Rakudo" can generate bytecode for the "JVM" and "MoarVM" virtual machines. When executing a script, rakudo does not need to compile the used "module"s because they should already be available as bytecode installed by Panda.
The piece of code (or its lexical environment) that called a given piece of code. Generally only known at run time.
A "pseudo-scope" to access "symbol"s in the "caller"'s "scope".
A naming convention where a word boundaries in a multiple word identifier is indicated with medial capitalization. For example, "isDeeply". Popular in Java, C++, C#, and Visual Basic.
See "kebab case", "snake case".
The butterfly-like logo of Perl 6 as can be observed at http://perl6.org.
The "bot" on #perl6 channel that will evaluate code for you in various versions of Perl 5, Perl 6 and "NQP".
A regex can record substrings of the "match"ed string that are matched capturing parts of the regex. That part (and the matched text) is a capture.
For example
if '..42' ~~ / \.+ (\d+) / {
# ^^^^^ capture
say $0;
# ^^ capture variable
}(...) is the capture syntax while its non-capturing counterpart is the grouping syntax : [...].
An atomic Compare And Swap. Primitive for lock-free multi-threaded read/write access.
In "grammar"s, regex of a "multi" form a category that are distinguished by their "longname". That includes the signature but also the value of the ":sym" adverb. An expression consists of tokens that belong either in the category "term" or one of the "operator"'s categories.
A regex definition for one of the term kinds :
token term:sym<name> { ... }1) Context Free Grammar. 2) see "Control Flow Graph".
A "string" is a sequence of characters. Like in Perl 5, there is no character type in Perl 6 so when someone says a character about a "value", he means a string with one character. In "Unicode" a character is called a "grapheme" and may be composed of many "codepoints". But a string represented in the "NFG" normalization form proper to Perl 6 has a codepoint per character. That leads to O(1) performance for many string operations. Depending on the level of abstraction, the length of a given string differs. The abstractions are bytes, codepoints and graphemes and the relevant methods are respectively .bytes, .codes, .chars.
Short for "IRC" channel.
Or a concurrent queue.
Release date for a Perl 6 implementation. It was a recurring joke because the year was not specified. But at FOSDEM 2015, TimToady announced that the target date will be Christmas 2015.
A pun on "circular saw". When bootstrapping a language in terms of itself, we must rely on circular definitions in various places. Obviously if we were really to use those circular definitions to implement our language, we'll just get stuck in an infinite regress. So instead we grab our trusty "circularity saw" to cut those circular definitions in a spot deep down, hopefully in a way that the resulting splice will be very difficult for the end-user to notice in day-to-day use.
If a syntactic construct, for example a pair of parentheses, surrounds another piece of syntax, the surrounding first part is called a circumfix.
say (2 + 3);
# ^^^^^^^ circumfix
say <a b c>;
# ^^^^^^^ circumfixA basic software structure in "OOP". See the Wikipedia entry.
Command Line Interface, what you see in a Terminal (window).
To "backlog".
Etymology: There is a website irclog.perlgeek.de providing either IRC logs or IR clogs, depending on how you interpret the domain name.
A routine parameter that is a callable with particular constraints on its own parameters. For example, you may only want to accept callables that take a Str as their argument:
sub call-me(&callback:(Str)) { ... }Not to be mistaken for Subsignatures.
See also "Closure parameters" in S06-routines.
Common Language Runtime, as used by Niecza/mono/.NET.
Parts of a program intended for user consumption that are not used to generate code. Beside the # that starts a comment ending with the current line, Perl 6 supports many syntactic forms for different kinds of comments. Like inline comments that can be used as "whitespace", or comments that appear after a name declaration that are included in the "pod" documentation.
A "compilation unit" is a set of files or a string that is compiled at once. It involves the "serialization" of code and data.
In a "dynamic language" like Perl 6, the compiler is also referred to as "interpreter". In simpler dynamic languages like Perl 5, the interpreter does not go through conceptual phases similar to the one for a compiler of non-dynamic language, the term compiler is rarely used.
When transforming "concrete syntax" to "bytecode", the first conceptual phase is called parsing and generates a "parse tree". Next the parse tree is transformed into an abstract syntax tree which is a form that can be optimised. Next the abstract tree is transformed to "bytecode" in a "compilation unit". Then, this bytecode is executed. Depending on the type of the data manipulated by the "program", bytecode can be transformed into optimised bytecode or into "machine code". These last two operations are forms of "JIT".
A "variable" with a ? "twigil". See http://design.perl6.org/S02.html#Twigils and S24.
A "pseudo-scope" to access lexical "symbol"s in the "scope" being compiled.
A composer is a syntax for defining "value"s. When values are "object"s, their composer is a "Huffmanization" of a "constructor" expression. For an example, see the "fat comma".
See "compilation unit".
Property of simultaneous computations sharing resources. It necessitates some form of collaboration to guaranty the consistency of the said resources. Computations are materialized by "process"es or "thread"s. Collaboration involves synchronization primitives likes mutexes, locks, semaphores. Perl 6 provides high level abstractions like "feed"s, "junction"s, "hyperoperator"s, "promise"s, "channels" so that the programmer is usually spared the explicit use of threads and the endless problems they involve.
Compare with "parallelism". See S17-concurrency.
An "object" "value" is concrete when it is not the "class" itself.
A context specifies the kind of value expected from an expression. A context may be "boolean context", "numeric context", "item context", "list context" or "hash context". Some "prefix" "operator"s are used to force the context.
Context is also information that can affect parsing
A "variable" with a * "twigil". Used to set up contextual information that can be shadowed by calls deeper in the "call stack". Heavily used in the Perl 6 compiler because Perl 6 is a very contextual language, so gathered information affects the parsing. See "keyword" for an example.
See also "lexotic", http://design.perl6.org/S02.html#Twigils and S24. Also called dynamic variable.
Without control flow statements, a program's execution would be purely sequential. A control flow statement generally uses a predicate and branches to one of its substatements according to the predicate value.
In "spesh", a "dominance" graph generated from "bytecode" analysis so that "Single Static Assignment" can be done.
A "variable" that has an unchangeable "value".
The OO way to construct an object. Composers are constructor "Huffmanization"s that are available for the most common types like "pair"s.
A "pseudo-scope" to access "symbol"s of the outermost lexical "scope", definition of standard Perl.
Comprehensive Perl Archive Network. A content delivery system for Perl distributions.
Short for CompUnitRepo, the type of objects that inhabit @?INC.
Short for CompUnitRepo::Local, the type of CompUnitRepo objects that refer to the local file system.
Short for CompUnitRepo::Local::Installation.
An "IRC" "bot" that reports when various projects have been updated. It used to give "karma" to those who pushed the changes to the project.
Perl code in production use at companies that has never been uploaded to CPAN. As in "how will this change affect the DarkPAN", which can't be answered because you generally don't have access to that code.
Code that is never called. For example
sub f() {
say 42;
return;
# everything below this is dead code,
# because the return; above prevents it from running
say 23;
}A piece of software that helps you to track down errors in your software. It typically allows things like stepping through code, setting breakpoints and inspecting variables.
a "keyword" that introduces a "symbol" and defines its "scope" and "extent". Perl 6 declarators are "has", "my", "state", "our", respectively for object variable , lexical variable, <stateful variable|/stateful> and package variable. Also the "twigil" /* in the name of a package or lexical variable sets its extent to "dynamic".
Either a developer (person), or a development version of a program, or a branch for development in a repository.
Depth First Search. See also.
A Test function that succeeds when its argument, a Code object, dies at run time. See S24.
An "operator" that produces a resulting "value" of a "type" different from its "argument"s. For example, all the comparison operators like == and lt are diffy (because they produce Bools), the range operators are diffy (because they produce ranges), but + and ~ and x are not diffy because they (sorta, kinda) emit what they accept.
The reason we care about operators being diffy or not is that you can basically only reduce on non-diffy stuff. So [+] makes sense, but [..] doesn't. ([==] actually does makes sense even though it's diffy, but that's because it's also chaining.) You also can't make assignment metaoperators from diffy operators. So += makes sense, but ..= doesn't.
"Doctor, It Hurts When I Do This." Well, stop doing it then.
The piece of code in the runtime that determines which (multi) method or subroutine to invoke.
A collection of 1 or more "compunit"s for installing locally, or for loading from a remote location.
Don't Repeat Yourself
"Domain specific language". See "slang".
A special-purpose language used for a particular problem domain. For instance, some web frameworks (such as Dancer) use a DSL so that programmers can write code in terms of routes and actions rather than lower level details of parsing HTTP requests and generating HTTP responses. See also https://en.wikipedia.org/wiki/Domain-specific_language
A "pseudo-scope" to access contextual "symbol"s in my or any "caller"'s lexical "scope".
the dynamic here is unrelated to the one in "dynamic typing". See "context variable".
Acronym for "Do What I Mean". A programming language designer motto.
One of the opposites of "lazy".
The ecosystem is a repository of Perl 6 modules installable by "Panda". "Rakudo *" releases include a tested subset of the ecosystem.
Something that intends to please everyone by catering for everybody's taste, yet in the end pleasing nobody, because nobody is catered for enough.
A list which contains no value. Denoted ().
An internet expression describing the very dramatic, spectacular or just funny failure of an endeavor. See the relevant Wikipedia entry.
A Perl 6 command that takes a string as an argument and executes its content as Perl 6 code.
A document originally written by "TheDamian", in which he tried to explain the "Apocalypse"s to the common (wo)man. Now only kept as an historical document for reference. See also "Synopsis".
See "import".
An expression is a part of a statement that is constituted of operators and their operands and gives a value. The semantic of an expression may depend on its "context". An expression is all or part of a "statement".
The extent is the interval of time a "first class" entity lives. The extent is different from the "scope" of a name. A "lexical variable" can be still alive when its name is out of scope if some reference still exists.
An extension to the default "bytecode" "instruction set" in "Parrot" or "MoarVM". Used to support "opcode"s specific to a language.
when available in a class, called when all other attempts by the "dispatcher" have failed.
Contrary to Perl 5, =>, the fat comma does not simply separate two values but makes a "Pair" out of them. The left value can be a "bare string". This is the only place where Perl 6 accepts a bare string. Example:
foo => barUsed of an "operator" that doesn't participate in forming metaoperators at all. (Because that would be "too fiddly" to get to work, presumably.) ?? !! is such an operator. The method call operator is another. (And hence .= is actually a special case, not a "real" metaoperator.) List assignment is also fiddly. (But item assignment is not.)
No meta in fiddly things. So you can't reduce, negate, reverse, sequence, cross, zip, hyperify or assignify fiddly operators.
First In First Out, a fairly common data structure in programming languages. In Perl 6 an array behaves as such when used as a "queue". See also "LIFO".
Sometimes a test will fail under some conditions, but not others; when this test passes some test runs and fails others, it's called flapping.
An entity that is accessible as a "value" during "runtime".
The creation of another process.
Also, a feature of "github" that copies a repository from one user to another, to allow users to make changes to a repository without needing permissions on the original project. After a user makes changes they will likely submit a "pull request".
Free and Open-Source Software.
Something in a generally current document that is no longer true but which has not yet been fixed by correcting or removing it.
Short for "functional programming"
An "IRC" server that hosts "channel"s related to Perl 6 projects accessible through an IRC client at irc.freenode.org.
For Some Value Of.
Fixed That For You.
Way to temporarily mark tests in the "spectest" for a specific Perl 6 version as todo (so that a failure of the test will be marked ok, and a pass will be marked as an exception), or as skip if they cause a "compile time" or "runtime" exception.
A programming style that mostly or exclusively relies on functions, "pure" or not. Perl 6 supports functional programming but does not force it on you.
Garbage collecting.
A generated symbol. Used primarily in "macro" parlance, a gensym acts as a "handle" on something anonymous, allowing a macro author to refer to synthetically created bits of a program after creating them. Gensyms generally look ugly, partly so as not to collide with anything else. The "symbol"s `#:G847`, `#:G848` and `#:G850` below from http://lists.warhead.org.uk/pipermail/iwe/2005-July/000130.html are gensyms:
(LET* ((#:G847 X) (#:G848 FOO))
(MULTIPLE-VALUE-BIND (#:G850) 1 (COMMON-LISP::%PUT #:G847
#:G848 #:G850)))Current consensus is that we won't need gensyms for Perl 6 macros, because we'll have Qtree nodes which, being objects, come pre-equipped with a "handle": their object identity.
A summary, or a method on objects that is invoked by "say" to print out the object in a human readable format.
Or a paste server with "git" capabilities used by denizens of "IRC". See https://gist.github.com for the last usage.
The distributed source revision system used by many, if not all Perl 6 projects, generally hosted on "github". A good glossary about git. A good reference.
A way to use a git repositories from one git repository. More information
Online open source repository hoster using "git". The "ecosystem" is hosted on github.
Keyword for the Perl 6 switch "statement".
A "pseudo-scope" for "interpreter"-wide "package" "symbol"s, really UNIT::GLOBAL.
The Great List Refactor: a refactoring of the reification of lazy lists, so that lazy evaluation is only done when it is really needed. Expected to provide a performance benefit of several factors in certain, loop-like situations.
Further Refinement of the "GLR".
Shortest possible way (least amount of typed characters) to get a program to do what you want, or to describe a problem or bug.
In the case of bug hunting, the aim is only partly "fewest characters" and partly "fewest concepts". The aim being to show exactly what concepts are necessary to trigger the surprising behavior.
The process of creating the shortest possible program to prove what you want. Sometimes also a form of "obfuscation".
Good morning/afternoon/evening. Since the contributors are in many different timezones, one contributor's morning is another contributor's evening.
"You wanted a banana but what you got was a gorilla holding the banana and the entire jungle." says Joe Armstrong, Erlang creator, complaining of traditional "OO" inheritance based environment inflexibility. In non "dynamic language"s, you can't dynamically add "attribute"s/"method"s for an "object"/"class" so you end up shoving everything you may ever need in a deep class hierarchy. In Perl 6, the gorilla/banana problem is solved with "role"s that group methods or attributes. A role can be dynamically added to a class or an object.
According to wikipedia Gradual typing is a type system in which variables may be typed either at compile-time (which is "static typing") or at "runtime" (which is "dynamic typing"). Perl 6 supports gradual typing.
A feature of Perl 6 that uses "regex"es to implement a grammar for parsing text. Perl 6 implementations use grammars themselves to parse the language. The results of parsing with a grammar can be further passed on to "actions". A grammar is composed of methods introduced by one of the three keywords rule, "token", regex. There is "backtrack"ing only in regex and rule implies "whitespace"s between subrules.
Parsing is done conceptually in two phases, lexing and "syntax analysis". Lexing breaks the input string in tokens that are the input of syntax analysis. In Perl 6, things are not so clear cut and both phases are defined in the "grammar".
Threads that are scheduled by the virtual machine, not by the operating system.
Command line utility to search text for lines matching a "regex". See http://en.wikipedia.org/wiki/Grep.
A data type, conveniently available in variables starting with the percent sign % and provided by types conformant to the Associative role like the Hash type. Often called associative table in other languages.
Dynamically allocated memory pool used for memory management. Unused parts are reclaimed by the "GC". See Memory management.
A high level language provides abstractions that decouples it from specific operating systems and processors. Perl 6 is such a language and provides some interoperability with other HLLs when they are compiled with the rakudo toolkit. Some of these abstractions like arrays, associative tables, integers, floats, strings and objects are common to many languages but specific semantic and underlying type "representation"s may differ. Also, a given language may provide many flavors of them. Perl 6 provides common "concrete syntax" to access them. MVMHLLConfig is the "MoarVM" C level structure that hooks to the underlying language specific representations. The "metamodel" allows one to express specific semantics proper to a given "OO" language. "Rakudo" provides interoperability with languages which compilers follow C language linking conventions.
Hacker news as seen on https://news.ycombinator.com.
Being mentioned on Hacker news (https://news.ycombinator.com).
Higher Order Workings. Also the name of the method you can call on any object to find out the meta-class of that object (of which the type object of an object is the instantiation).
Harry Potter and the Methods of Rationality. An inexplicably good Harry Potter fanfic with far more significance than the word "fanfic" might lead you to believe. See http://hpmor.com.
Huffman coding is a compression algorithm that encodes common symbols with a short code. By analogy, we call huffmanization alternative and shorter syntax for common syntax constructs. The cost of huffmanization is the cost of learning additional syntax. In Perl 6, "composer"s are a form of huffmanization.
Process data asynchronously when possible, but return the result data in the order it would have been if the source data had been processed in a single thread/process.
Pun on historical reasons.
I see.
Used of an operator that either returns a Bool result, or something like it (such as a match object). All the comparison operators are iffy, as are conditional operators like &&, ?^, and or. %% is iffy, but % isn't. The junctive operators are iffy.
The reason that we care about iffy operators is that you can only append the ! metaoperator to an operator that's iffy.
If I Remember Correctly.
If I Understand Correctly.
Modules interact with each other through named entities called symbols. The operation that makes symbols from a module available to another module is called import while the operation of using such a name is called import.
An operator that can appear between two terms, like the + in 40 + 2.
A built-in arbitrary-sized integer type. See http://doc.perl6.org/type/Int.
An interface is an "abstract class".
In a compiler, Intermediate data structures that are generated from the "source code" to generate "object code" or "bytecode". In "Rakudo" : "parse tree", and Abstract Syntax Tree. The "parser" generates an IR that is transformed to an "AST". Sometimes the information can be regenerated from the bytecode. In Rakudo the "Single Static Assignment" form is inferred from the bytecode.
An interpreter is the entity that executes "bytecode" generated from "source code" in a given "language". It relies on the underlying "VM". It may load extops, that is bytecode "ops" that are specific to the said language.
An instruction set is a set of instructions specific to a "bytecode" or a microprocessor. Also "NQP" defines an instruction set. Its opcodes are documented in ops.markdown.
A "method" has generally one invocant but may have many according to its "signature". As a parameter(s), the parameters before the ;. As an argument, the left "operand" of the . "operator". In the expression 42.say, 42 is the invocant. When missing, like in .say, the invocant is $_.
An "opcode" that makes possible the support of "dynamic language"s in "JVM". A presentation about invokedynamic.
See "Intermediate Representation"
Internet Relay Chat. Perl 6 developers and users usually hang out on the "#perl6" "channel" on "freenode". See also http://perl6.org/community/irc.
I Seem To Remember.
A way to go through all the values of an "Iterable" object like a "list" or a "hash". Generally, iterator "object"s are invisible from user code because syntactical forms iterate for the user and pass the resulting value to the expression or the block acting on the value. Example:
for 1..20 { .say }
.say for 1..20It Would Be Nice.
"Rakudo" running on the "JVM".
Intermediate representation of code used in the JVM backend of Rakudo and NQP.
Just-in-time compilation, a technique for improving the performance of virtual machines.
A popular data format. Its specification The ecosystem includes many JSON related "projects". Its binary counterpart is "BSON". The class "JSON::Pretty" is part of the core. Thre is also support for more JSON and BSON in the "Rakudo Star" or the "ecosystem".
A compound type that is transparent to many operations. See http://doc.perl6.org/type/Junction.
Java Virtual Machine. The virtual machine for the Java programming language. Now many programming languages including Perl 6 have "compiler"s targeting the JVM.
A measure of appreciation on "IRC". Karma is set by "incrementing" a pseudo: "jnthn++ # moar commit". It is purely notional on "#perl6" and other Perl 6 related channels because "dalek" does not track karma anymore.
A naming convention where a word boundaries in a multiple word identifier is indicated with a dash (-) character. For example, "is-deeply". Popular in Lisps and Perl 6.
See "camel case", "snake case".
An alphabetical string that has a predefined meaning in the language source code. In most languages keywords are reserved, that is they cannot be used as "symbol". Not in Perl 6, the compiler knows by context if an alphabetical string is a keyword, a "function" name used for a call or a sigiless "parameter". This will allow to add new keywords to Perl 6 in the future without breaking existing programs.
Keep It Simple, Stupid!, a famous motto in computer science.
An anonymous function. A block with explicit parameters: -> $a { say $a } The -> itself, or <-> for writeable parameter.
The property of a list not to evaluate elements until they are needed.
According to "WP" "lazy evaluation, or call-by-need is an evaluation strategy which delays the evaluation of an expression until its value is needed (non-strict evaluation)". In Perl 6, strings and lists can be lazy but other values are not. That is, their content is evaluated when needed so they can be potentially infinite. As of January 2015, lazy strings are not supported. They may even not make the cut for the 6.0 specification.
Lexical properties are derived from the structure of the source code itself, not from any information from run time.
A data structure that holds the values of lexical variables.
A dynamic operation with a lexically scoped target. For example, return has a dynamic effect (it peels back the call stack), but the thing it's returning from is a lexically defined routine.
Short for "lexical pad".
Looks good to me.
Low Hanging Fruit.
The compilation of a "compilation unit" of source code written in a non-dynamic language like C results in a library.
Last In First Out, a fairly common data structure in computer science. In Perl 6 arrays behave as such when used as a "stack". See also "FIFO".
Used to qualified unreadable code. Often used by people that don't understand the syntax of the used language. Perl is often deemed line noise, especially because of its abundance of "metacharacters", like "sigil"s. For the trained reader, they are very useful because the sigil denote an associated "role"
See "TheDamian" /answer to the question Perl looks like a regular expression.
A facet of a language's design that puts the onus on the user to remember which of a group of similar constructs have certain behaviors (or requires frequent consultation of documentation to the same effect.) A goal of language design is to minimize the amount of material a user must remember, by using consistent behaviors across similar constructs, or by exposing these behaviors through syntax. A natural language analogy to "list to remember" would be irregular verb conjugations.
Let Me DuckDuckGo That For You. http://lmddgtfy.net
Let Me Google That For You. http://lmgtfy.com/
A local variable, in "QAST", is local to a "frame". A "HLL" lexical variable may end up as local in QAST if it is not captured by outer "scope". When the QAST is compiled and "JIT"ed to an executable, the value accessible thru the local, modulo some "SSA" magic, is accessible in a processor register. There is no relationship with the local scope in Perl 5.
List of List
Because Perl 6 has the capability of "multiple dispatch", several methods or subroutines may have the same name but different parameters (different in number or in type). Perl decides which routine to call by looking at the longname which consists of the name of the routine and the type signature of its invocant arguments. See also "shortname", "multi-method", and "multi-sub".
Less Than Awesome.
Code specific to the "instruction set" of a hardware architecture. Compare with "bytecode".
Variable that has a behavior of its own and that is denoted by a sigiless name with a non alphanumeric character. Unlike Perl 5 that has a profusion of magic variables, Perl 6 includes only the magic variables "$_", "$/", "$¢" and $!. They are "block" "scope"d and are implicitly defined at the beginning of each block.
When present, a "multi"sub that is the entry point of a "program" "runtime". The code in "phaser"s intended to run at compile time are executed before MAIN. Like in Perl 5, a MAIN sub is not necessary.
"MoarVM" specific "AST". When the Perl 6 "backend" is MoarVM, "QAST", the AST obtained from early stages of "source code" "compilation" is converted into MAST. The MAST is then used to generate MoarVM "bytecode".
Value resulting from a "match". In "list context", gives the positional "capture"s list. In "hash context", gives the named "capture" hash. In "numeric context", gives the matched string length. In "boolean context", gives True like any non-class object.
A match is an operation that tests a "string" against a "grammar" or a "regex". and returns an "object" of Match type in case of success, otherwise a "Nil"
Matching against a regex is a special case of "smart match"ing.
See also "parse".
A "JSON" file that lies in the root of a "repository" for a project written in Perl 6. It describes a project and list its dependencies. Documented in spec.pod.
The metamodel describes some OO behaviors, like where to find a "method". This permits implementation of different OO behaviors in the same "VM". The Perl 6 implementation of the metamodel is called "6model". The metamodel should not be confused with the "representation".
Methods are "sub"s that are called with an "invocant".
Multiple inheritance.
A case of having put a message on the wrong (IRC) channel.
A virtual machine designed specifically for "NQP" and its "MOP": "6model". A document about MoarVM purpose. MoarVM has some similarities with the Hotspot VM so you may peruse its glossary for entries missing from the present one.
It is an "adverb" that affects the behavior of a "rule" or a "match" The supported modifier for rules are ":ignorecase", ":ignoremark", ":sigspace", ":ratchet", and ":Perl5", and their respective abbreviations :i, :s, :r, and :P5.
:g :ov :x :ex :pos
Meta-Object Protocol.
Method Resolution Order.
The mystical class from which all other classes are derived (�).
"sub"s, "method"s, or "rule"s that have the same name but are distinguished by their signatures. Keyword that introduces them. The operation that dispatches a call to the appropriate method is called "multi-method dispatch".
Dynamically selecting which routine to execute based on name and type of arguments.
Placeholder; something that's left unclear deliberately. Either because the speaker doesn't know or because it's an unimportant detail.
A "pseudo-scope" to access "symbol"s in the current "lexical scope" (aka $?SCOPE).
Something that does not pertain the Perl interpreter proper but to the "backend" or the underlying system. See also: "pure Perl"
Calling a routine from an external C/C++ library, provided by the NativeCall library (which is now bundled with "Rakudo").
A native value is an "int", "num", "str". A native value cannot be undefined.
Syntactical convention to denote an entity in a program source code. Such an entity can be a routine, a variable... See also : "symbol", "scope", "sigil", "role", "adverbial pair".
"Native Call" Interface
Nondeterministic Finite Automaton, an algorithmic technique used by the regex engine. See: https://en.wikipedia.org/wiki/Nondeterministic_finite_automaton.
Proposed "Unicode Normalization Form" for Perl 6, in which composed characters always get their own codepoint. If a codepoint doesn't exist for that composed character, one is assigned dynamically.
Documentation for this can hypothetically be found in S15.
An implementation of Perl 6 targeting the .NET platform.
Means there is no value. This is different from (), the "empty list".
No Such Thing.
The name of the main branch of current "Rakudo" in "git". Originally named so for its "new object model".
Null Pointer Exception.
Short for Not Quite Perl, a subset of Perl 6 suitable for tasks such as implementing "Rakudo". Targets "Parrot", the "JVM" and "MoarVM".
Native, Shaped Arrays.
Code deliberately unreadable often using esoteric language features. Sometimes combined with "golfing".
For non "dynamic language"s, from a "compilation unit", the "compiler" generates object code or library. A latter phase links object code to generate an executable. For dynamic languages like Perl 6, the equivalent of object code is the "bytecode" and the linking phase is more complex and involves the de"serialization" of information.
According to the hotspot glossary: The process of converting an interpreted (or less optimized) "stack frame" into a compiled (or more optimized) stack frame.
Object oriented. See "OOP".
Acronym for Object-oriented programming.
Ops are "opcode"s that belong to the "NQP" interpreter or that are dynamically charged by the interpreter of another language. The word "extops" is used to denote the latter ops
An opcode is an instruction in a "bytecode" or "AST". Documentation about "MoarVM" opcodes.
See "operator".
An expression is made of operators and operands. More precisely it is made of an operator and operands that can be subexpressions or "value"s. Operators are an alternative syntax for a "multi-method". With that syntax, what would be the "argument"s of the function are named operands instead. Operators are classified into categories of categories. A category has a precedence, an arity, and can be "fiddly", "iffy", "diffy". Perl 6 is very creative as to what is an operator, so there are many categories. Operators are made of many tokens, possibly with a subexpression. For example, @a[0] belongs to the postcircumfix category, is broken into the operand @a and the postcircumfix operator [0] where 0 is the postcircumfixed subexpression.
The <O(...)> construction gives information about an operator that completes the information provided by its category. Below %conditional is the category, :reducecheck<ternary>, which specifies calling .ternary to post-process the parse subtree and :pasttype<if> specifies the NQP "opcode" generated in the "AST" from the parse subtree.
<O('%conditional, :reducecheck<ternary>, :pasttype<if>')>An optimization, usually in either the context of "spesh" or "JIT".
Operating system. See http://en.wikipedia.org/wiki/Operating_system.
A "pseudo-scope" to access "symbol"s in the current package (aka $?PACKAGE).
A "pseudo-scope" to access "symbol"s in the next outer "lexical scope".
See "lexical pad".
The simplest object containing a key and value pair.
Way of expressing key/value pairs, using the "fat comma", creating a "Pair" object, for instance:
foo => 1Compare with the "adverbial pair" notation.
A Perl 6 "package manager" designed to make it easier to download, compile and install "module"s according to the transitive dependencies specified in the META.info metadata files of said modules. Unlike other "package manager"s, panda supports many "VM"s, namely the three VMs supported by the "Rakudo" compiler: "MoarVM", "Parrot" and "JVM". The official set of modules is called the "ecosystem" according to the "github" repository name that contains the module list pointing to their respective repositories.
In a "signature", defines how the corresponding "argument" is bound when the "block", "sub" or "method" with a signature is called. Is often designated as "formal parameter" in the literature about other languages. A parameter can be "positional" or "named", either can be "variadic" or not.
See "parakudo".
A "pseudo-scope" to access lexical "symbol"s in the unit's DSL (usually CORE).
A virtual machine designed to run Perl 6 and other "dynamic language"s. Mostly historic.
The parser is the "compiler" part that transforms the "source code" into a "parse tree". A parser is specified by a "grammar". The code used by the parser leverages three different engines: the expression parser, a recursive engine, an "NFA" based engine. "LTM" is a feature of the "NFA" engine. One difference between | and || is that the former involves an "NFA", while the latter involves the recursive engine. That's why the former is faster than the latter.
See also "grammar".
Perl Authors Upload SErvice. The place where authors upload their distributions to "CPAN".
Short for "problem". As in "that's not the pb".
"Perl Best Practices". The book by Damian Conway outlining best practices when programming Perl 5.
Parrot Design Document. Numbered documents detailing various parts of the design of Parrot.
Could also be used to refer to "Presentation-Driven Development", the practice of implementing a feature after having submitted a presentation about said feature.
Parsing Expression Grammar. See "grammar".
A "compiler" project that has frontends for Perl 5 and Perl 6, as well as multiple backends.
A piece of code (a "blast") that runs at a particular phase in the program's lifecycle, for example during compilation (BEGIN), the first time a loop is entered (FIRST), or after all regular code has run (END).
An implementation specific internal object for doing I/O. Originally a Parrot I/O object, now a Perl I/O object.
Parrot Intermediate Representation.
Parrot Magic Cookie.
Plain Ol' Documentation, a documentation format understood by Perl 6. See S26 for details.
Used to specify Perl 6's version of "pod", as opposed to Perl 5's.
See "lambda".
Principle Of Least Astonishment.
Principle Of Least Surprise.
A "role" denoting an linearly ordered composite data structure that can be iterated.
An operator that follows a term directly and encloses another term inside it. For example:
my $friend = @names[15];
# ^--^ circumfix
# post--^An operator that comes after the term it belongs to.
Perl 5 module for parsing, analyzing and manipulating Perl 5 source code. https://metacpan.org/pod/PPI.
A pragma is a module which influences some aspect of the compile time or run time behaviour of Perl.
The order in which operators bind terms together; tighter precedence evaluates before looser precedence. See "Operator precedence" in S03 for details.
Precompiled "compilation unit".
An operator that comes before the term it belongs to, for example
say ?42; # True
# ^ prefix operatorExpression used in a "boolean context" by a "control flow" "statement".
A composite codepoint (that is, formed of many "codepoint"s), for which "Unicode" assigns a codepoint. Thanks to "NFG", a composite non precomposed codepoint (aka a synthetic one) has its own dynamically assigned codepoint.
Basic execution unit in a multitasking operating system. Processes differ from "thread"s in the sense that they are directly managed by the operating system itself.
A "pseudo-scope" to access "process"-related globals (superglobals) "symbol"s.
A project is a "version"ed "repository". It typically contains a bin folder and a lib and t hierarchy. They respectively contain executable scripts, Perl 6 libraries and tests. The list of projects is maintained in the ecosystem repository. The "META.info" file drives the compilation and installation of the project by the "project management software".
A "program" that fetches, compiles and installs "project". "panda" is such a program.
a "package" name which meaning is contextual or predefined by the language. For example MY denotes the current "lexical scope" and its "symbol"s can be listed with MY::.keys.
A proto is a generic "dispatcher" to "multi"s by the same "shortname".
Short for "pull request".
Perl 5 script to run tests through a "TAP" harness. See prove.
Problem, Solution, Acceptance.
A feature of "github" that's used after a user has "fork"ed a project and made changes to it that they wish to have in the main project.
A Perl 6 implementation in Haskell, led by the efforts of Audrey Tang. The first truly usable Perl 6 implementation, it was actively developed 2005 through 2007.
Another name for "magic variable".
When a role is used as a class, punning is the implicit operation that converts the role to the class using the metaclass compose method. In a wider, non-Perl 6 context, it can refer to any implicit conversion.
A "function", "method" or "op" is pure if it has no side effect, and the value it gives is depends only of its arguments so it is referentially transparent giving the opportunity of optimizations.
Use to qualify Some source code, or "project" that does not depend on non Perl resources like a "shared library" generated from C code.
Short for Perl 5, the (older brother|parent) of Perl 6.
Short for Perl 6, the (spunky little sister|child) of Perl 5.
See "Weekly Changes".
Successor to "PAST".
Process data asynchronously when possible, and don't care in which order the result data is returned.
An implementation of Perl 6 originally targeting "Parrot", it now targets Parrot, the "JVM", and "MoarVM" through "NQP".
Rakudo Star, a useful and at most monthly, at least quarterly distribution of Rakudo which includes modules and "Panda".
See "Rakudo *".
Quick and dirty command line tool for managing "Rakudo" installations on Unix boxes. It can fetch the latest code from "github", build against your choice of "backend"s, and simplify version upgrades.
Definition adapted from from "http://iinteractive.com/notebook/2015/06/02/rakudobrew.html".
Daily build reports on rakudo-star to track module tests on each "backend". Its README
A bug in "Rakudo". Usually used in contexts such as "/me submits rakudobug".
Short for Regular Expressions, an easy way of parsing text for certain kinds of information.
An alternative abbreviation of "regex" that usually occurs in non-Perl 6 contexts.
Certain composite objects like "range" are defined in the abstract. They are partially or totally reified on demand, that is, their composant objects are created only when they are needed. Without that laziness, some objects would consume too much "memory" or would not even fit in memory like the infinite "range": 1..Inf See also "laziness".
Read Eval Print Loop. Read a line of code, evaluate, print, wait for new line of code. Commonly used to experiment with code and get results whenever a line is finished.
A repository contains the information pertaining to a software or its "module"s. That is the source code, its history and ancillary information like a wiki, a bug tracking system, a static web site, depending on the hosting service containing the repository. Usually Perl 6 related information is stored in "github" repositories. The official list of Perl 6 modules is the "ecosystem" which is also stored in a repository. When installing a module, the "panda" "package manager" uses the ecosystem to fetch the appropriate repositories for transitive dependencies.
Representation.
In MoarVM, low level C code associated to a data type. Typically an NQP call for a type translates into a MoarVM instruction (opcode) that calls a function in the representation table of that type.
Require is the "runtime" loading of a "module" and the related "import"s
Revert is "git" terminology. It adds a new commit to revert some changes in a branch. It is different from a reset that throws away changes.
The Perl 6 specification tests, which live here: https://github.com/perl6/roast/. Originally developed for "pugs", it now serves all Perl 6 implementations. Why roast? It's the repository of all spec tests.
A role can be composed with zero or more other roles, then instantiated into a "class". The "sigil" of a variable name indicates that the defined value in the container denoted by the variable belongs to a class composed from the associated role. For example, the sigil @ denotes the Positional role. So a variable @a may contain a value of type List because List.does(Positional).
1) Release Candidate, a last chance to find terrible bugs or non-portabilities before the actual release.
3) Request Context.
In precompilation, if an object inside a module, changes an object in another precompiled module, it needs to indicate that it is now responsible for its serialization: this is called "repossession" of the object by the module.
See root object. In "MoarVM", routines that handles roots are declared here.
Rosalind is a platform for learning bioinformatics and programming through problem solving. Some of the problems are solved through elegant Perl 6 code snippets.
Rosetta Code, a site for comparing snippets from different languages in how they solve various tasks.
Resizable "PMC" Array.
Real Soon Now.
Request Tracker (http://rt.perl.org/). To open a ticket, email> [email protected].
A test for a basic feature that robs your sanity if it doesn't work, and the fact that it doesn't work goes unnoticed.
A "serialization context" groups together things, usually from the same "compilation unit".
Association of a name with an entity delimited by a "block".
A "program" executable in its "source code" form. Implicitly depends on the setting or explicitely "use" "module"s from the "ecosystem"
See "segmentation fault".
Something that should never, ever happen. Complain on #perl6 if you see one.
A "character" used to separate or terminate "statement"s.
The serialization saves information obtained at compilation time from a "compilation unit" to be deserialized at load time to perform various initialization tasks. The saved information involves named constants, strings, among many other things.
A "pseudo-scope" to access "lexical symbol"s in the unit's "DSL" (usually CORE).
Library set that is loaded by default. When possible, the setting is loaded lazily to optimize loading time.
"operating system" level "library" dynamically loaded by a "process". When different processes load the same library, it is loaded once in memory, so the shared adjective.
The name of a routine only; without the type signature of its invocant arguments. See "longname".
In Perl, the sigil is the first character of a variable name. It must be either $, @, %, or & respectively for a scalar, array, hash, or code variable. See also "twigil" and "role". Also sigilled variables allow short conventions for "variable interpolation" in a double quoted string, or even postcircumfix expressions starting with such a variable.
A signature is used by "block"s, "sub"s or "methods" in L to specify the "arguments" they can receive when they are called.
Context of an expression whose value is ignored. Often called "void" context in other languages.
sixplanet is a collation of blogs related to Perl 6. If planeteria.org is down, a replacement can be found on http://pl6anet.org/.
Short for sublanguage. A slang is a "grammar" derived from the Perl 6 grammar, and its associated "actions". Alternatively the Perl 6 syntax can be seen as the combination of many slangs (the regex slang, the quotation slang...) Defining a slang has a cost because it usually involves generating new "NFA" tables; except for the space taken by the said tables, it is compilation time cost. Slang is a principled way to create Domain Specific Languages (DSLs).
A naming convention where a word boundaries in a multiple word identifier is indicated with an underscore (_) character. For example, "is_deeply". Popular in Perl 5, Python, and other scripting languages.
See "camel case", "kebab case".
Small/Simple Matter Of Programming. The thing you do when not specifying, documenting, discussing, lurking or idling. See also here.
A parameter that will "slurp up" any excess named or positional parameters and present them as a hash or list respectively.
A specification that has frozen chunks in it, but remains frustratingly fluid. Ranges from S02 and S03 which are nearly frozen, to S16 which is more like a glass of ice water.
Textual form of a "program".
Alternative name for "roast" after the name of its target name in "rakudo compiler". A program that passes the Perl 6 "test suite" is a valid Perl 6 "compiler". Link to the "github" "repository" that contains the said test suite.
Variable with one of the "twigil" ?, * or =; or "magic variable". The said twigils respectively correspond to "compiler constant"s, "context variable"s or "pod" data.
See S28.
A functionality of the "MoarVM" platform that uses run-time gathered data to improve commonly used pieces of "bytecode". It is much like a "JIT" compiler, except that those usually output "machine code" rather than bytecode.
See "Single Static Assignment".
See "frame".
Representation independent data structure associated with the type of an object. Part of the "6model". See http://jnthn.net/papers/2013-yapceu-moarvm.pdf.
Can denote steps either on bootstrapping NQP, or compilation stages.
For bootstrapping stages, see "bootstrap".
Compilation proceeds on successive stages. Later stages are "backend dependent". When there is a dumper available, you can see the output of one stage with the switch --target=stage_name. The argument is case insensitive. The backend independent stages are parse and ast. The "JVM" backend specific states are jast, classfile, jar, jvm. For "MoarVM", they are mast, mbc. moar.
See "Rakudo *".
Data pertaining to a "frame" gathered at compile time.
In a language with stating typing, at "runtime", values don't need to be annotated with their type. See "type erasure".
Compare with "dynamic typing", "gradual typing"
Software Transactional Memory.
Name of the string type.
A sequence of characters. See "characters" for the definition of string length according to the different abstractions underlying a "Unicode" string. There is some speculation of string being "lazy" in some future Perl 6 version.
Short for subroutine.
A subroutine is like a "block", but its "runtime" context is stacked. When a subroutine is called, its context is pushed in the context stack and the code pointer moves to its block. When executing a return, the context stack is popped and the return argument becomes the value of the calling expression.
Similar to destructuring bind in Lisp, pattern matching in Haskell/the ML family of languages.
Allows you to specify a construction pattern in place of a normal parameter; the argument supplied at call time will be used to populate variables in the pattern. For example:
sub quicksort (@data, $reverse?, $inplace?) { ... }versus
sub quicksort ([$pivot, *@data], $reverse?, $inplace?) { ... }See "Unpacking a single list argument" in S06-routines, "Unpacking tree node parameters" in S06-routines.
Not to be confused with Closure parameters.
Fancy alternative way to denote a name. Generally used in the context of "module"s linking, be it in the "OS" level, or at the Perl 6 "VM" level for modules generated from languages targeting these VMs. The set of "import"ed or exported symbols is called the symbol table.
The current human-readable description of the Perl 6 language. Still in development. Much more a community effort than the "Apocalypse"s and Exegeses were. The current state of the language is reflected by roast, its "test suite", not the synopses where speculative material is not always so flagged. This is even more true of material that is deemed to pertain to 1.0 version of the language but has not been yet implemented.
See "parser".
See "Huffmanization".
A codepoint for a "grapheme" composed of many "codepoint"s that has not a </precomposed codepoint> defined by "Unicode". "NFG" dynamically assigns its own codepoint for such a composition.
A "bundle" that directs "Panda" to install "Rakudo *" "module"s.
"tail call" optimization.
The Perl 6 test suite is "roast"
The ASCII variant of a non-ASCII Unicode operator or symbol. For instance, >>+<< is the "ASCII" form of the »+« hyper-addition operator, and (elem) corresponds to the � ("Is this an element of that set?") operator that comes from set theory. ASCII operators are a workaround to the problem that people don't know how to type Unicode yet. Culturally, while we encourage people to use the Unicode symbols in a vague sort of way, we do not disparage the use of the ASCII variants. Well, maybe just a little...
"IRC" screen name for Damian Conway, writer of the original Exegeses.
A thinkographical error; i.e. a small mistake made by improperly expecting code to "DWIM" or from an interrupted thought process.
An execution unit more lightweight than a "process". Threads allow parallelization of code for concurrent performance but it is tricky to modify information shared by the different threads of a process. Perl 6 provides many primitives that create threads when needed so direct thread use is possible but should be done only when necessary.
A piece of code that isn't immediately executed, but doesn't have an independent scope.
Examples for thunks:
my $a;
$a = 1 if 1;
# ^^^^^^ thunk
class MyClass {
has $.attr = 42 + 23;
# ^^^^^^^ thunk
method x($attr = say 42) {
# ^^^^^^ thunk
}
}
$a = 1 || say 2;
# ^^^^^ thunk"IRC" screen name for Larry Wall, creator of Perl. The name comes from the pronunciation of "TMTOWTDI" as a word.
An alternative form of "TMTOWTDI", explicitly including the "is" from the contraction "There's".
Too Long; Didn't Read. Also denotes a summary for those who are prone to claim tl;dr.
Too Much Information.
"There's More Than One Way To Do It", the Perl motto.
A token is a keyword that introduces a lexing "rule" in a grammar
Expression whose value is aliased to $_.
Two Terms In A Row. A common error message often resulting from a missing "semicolon" between two "statement"s or putting an operator directly after a "sub".
Typo.
The mystical unit of effort in the open source community. Sometimes materialized in wooden nickels.
A secondary "sigil". For example, %*ENV has a sigil of % and a twigil of *.
See http://design.perl6.org/S02.html#Twigils and S24.
The type of a value $val can be obtained using $val.WHAT which the corresponding type object. When a value is native, the <.WHAT> macro operates on the corresponding boxed value.
Type annotation for a value of "static type" is unnecessary at "runtime" The absence of that annotation at compared to "compile time" is called type erasure.
Unicode Standard Annex. Unicode standard material that is not part of the core. Some are specific to some languages while others are generic, like UAX 15 which covers "Unicode Normalization Form"s.
See "Unicode Character Database".
See "boxing".
A way to put "whitespace" in your code that is ignored by the parser. Introduced with a backslash.
See here.
"Universal Greeting Time" - i.e., it's always "morning".
An operator is unary if its "arity" is one. Operators belonging to the categories "prefix", "postfix" and "circumfix" are unary.
Unicode is a standard defining the encodings, representation and handling of text in most writing systems. This standard includes a useful Unicode glossary. For Perl 6 handling of Unicode, see the documentation. See also "NFG" for an encoding specific to Perl 6.
It consists of a number of data files listing Unicode character properties and related data. It also includes data files containing test data for conformance to several important Unicode algorithms. See also.
See "UAX" 15. Perl 6 defines an additional one : "NFG".
See "compilation unit".
Symbols in the outermost lexical scope of a compilation unit.
The amount of memory a "REPR" has behind it that is not under the direct management of the "GC". Used for "heap" profiling.
See "slushy".
Use is the compilation time loading of a "module". That means, contrary to "require" that the "import"ed symbols are known at compilation time to the rest of the compilation of the code
A variable is a name for a "container".
See "sigil" and "Q forms" in S02.
Short way to indicate "version".
Can be obtained with perl6 -v with perl6 depending on your "implementation". This command gives something like that below for "Rakudo" on "MoarVM"
This is perl6 version 2014.08-187-gdf2245d built on MoarVM version 2014.08-55-ga5ae111Strangely the "NQP" related information is missing.
An "object variable" declared with the ! "twigil" can be in scope but is not visible.
A virtual machine is the Perl compiler entity that executes the "bytecode". It can optimize the bytecode or generate "machine code" Just in Time. Such as "Parrot", "JVM" and "MoarVM".
See "Virtual Machine".
Stands for "Perl, version 5" and is used in code to indicate that the code is Perl 5:
use v5;Stands for "Perl, version 6" and is used in code to indicate that the code is written in Perl 6:
use v6;This lemma will never be explained.
https://www.destroyallsoftware.com/talks/wat. Often used as the opposite of "DWIM".
Mostly weekly report about changes in the Perl 6 World. See also: "sixplanet".
Works For Me.
http://doc.perl6.org/type/Whatever.
The negative space between syntactic constructs within a language. Typically consists of spaces, tabs, newlines, form feeds, and other "invisible" characters. For the purposes of parsing Perl 6, "comment"s are also considered whitespace. See also "unspace".
Work In Progress.
The world is the data about a package that is serialized when compiling a "compilation unit". the nqp and rakudo compiler have a World class handling the said data. See NQP::World and Rakudo::World.
Wikipedia.
Short for wrong window. When on IRC, someone types something in a channel that was intended for another channel, or for a private message.
Perl 5's mechanism for bridging the gap between pure-Perl code and compiled system libraries. Writing XS modules involves C code and some knowledge of Perl 5's inner workings, and installing them needs a compiler. The Perl 6 equivalent is NativeCall; see S21.
Sometimes people want to achieve X, and think Y is the best way to do it. So they ask "How do I do Y?", but doing Y is actually harder or less idiomatic than solving X some other way. So the person asking how to do Y has an XY problem.
Yet Another Potentially Awkward Explanation. A term referring to the "curious corners" of any given language, specifically the kind of example (mis)features of a programming language which are thrown by various sides in a flame war.
These examples are understood to be places where the actual design choices of a given language become visible.
The "bot" on #perl6 that is your personal assistant. See https://github.com/dpk/yoleaux and http://dpk.io/yoleaux.
Zavolaj was a module to support "Native Call"s into libraries. It is now part of "Rakudo"
A Zen slice is a slice of an object without specification of the elements. As such it is empty, yet it is supposed to return the object in its entirety. Usually used as a way of interpolating entire hashes / arrays in strings.
Oh, um... "Whatever".
"IRC" "channel" on "freenode" that hosts discussions related to Perl 6. Archived on http://irclog.perlgeek.de/perl6/.
Everybody wants the colon.
See "empty list".
The Perl 5 style argument list. Something you should stop using, and use subroutine signatures instead.
The "topic variable". Set by any construct that's a "topicalizer", like the "given" statement or a for loop.
A "magic variable" which "value" is the current "Match", or "nil" if none.
A "magic variable" which "value" is the current "Exception"
Way to increase "karma" on IRC. A "prefix" or "postfix" incrementation "operator".
Sigil of a "callable" "variable". Also used at the end of a line in an "IRC" message to indicate the user is away, doing something else in the background. For instance:
sleep&The "new object model"/"MOP" that's currently in rakudo. "MoarVM" uses this internally. On "Parrot" and "JVM", it sits on top of the native object model.
Elizabeth Mattijsen ([email protected])
Moritz Lenz
Larry Wall