This page was generated by Text::SmartLinks v0.01 at 2015-07-04 04:48:05 GMT.
(syn ace089e)
  [ Index of Synopses ]

TITLE

Synopsis 99: Glossary

VERSION

    Created: 26 June 2013
    Last Modified: 26 Feb 2015
    Version: 8

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

A

Abstract class

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.

ack

An improved version of "grep", written in Perl (http://beyondgrep.com).

Also used by old folks to indicate acknowledgement.

actions

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", the one to retrieve an AST is called "made".

adverb

See "adverbial pair".

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 => False

AFAICS

As Far As I Can See.

AFAICT

As Far As I Can Tell.

AFAIK

As Far As I Know.

afk

Away From Keyboard. Logged in, but there's no one looking at the screen.

ALAP

As Late As Possible

Any

The class from which most things derive, except for "Junction"s. Any is derived from "Mu".

any()

A Junction with "or" semantics.

API

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.

Apocalypse

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

arity

Number of "operand"s expected by an "operator".

argument

array

AST

Acronym for Abstract Syntax Tree. Used in many places, including "actions", "PAST", and "QAST".

atomic

See "CAS".

attribute

Per-object storage slot. Other languages call it "Field", "Member", "Slot" or "Property".

auth

Way of deliberately ambiguously expressing "author" or "authority".

author

authority

autopun

"Are you ignorant or apathetic?" - "I don't know, and I don't care."

B

backlog

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.

backtrack

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.

backend

Denote a VM targeted by "Rakudo". Can be "MoarVM", "JVM" or "Parrot".

Bailador

Spanish for "dancer", The Bailador module (https://github.com/tadzik/Bailador/) is a port of Perl 5's Dancer web framework (http://perldancer.org/).

bare string

A non-quoted alphanumeric string. In Perl 6, only allowed at the left of a "fat comma".

biab

Back In A Bit. Only "afk" for a little while.

binary

An operator is binary or of "arity" two if its "category" is "infix" or "postcircumfix".

blast

"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();
    #   ^^^^^^^^^^^^^^^^^^^^          Statement

Particularly cute, because "phaser"s expect blasts.

block

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

blorst

"Block, OR Statement". Different way to say "blast".

Bool

Boolean type.

boolean

Value of type "Bool". Apart the class itself, can be either True or False.

boolean context

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.

bootstrap

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

bot

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.

boxing

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.

branch

brb

Be Right Back. Only "afk" for a little while.

BS

Bounded Serialization.

BSON

BSON is the binary counterpart to the textual "JSON" data format. Used by Mongodb and supported by the MARTIMM/BSON "project".

Bug report

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.

bundle

A bundle is a special "module" that directs "Panda" to install a list of modules. See also: "Task::Star".

bytecode

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.

C

callable

caller

The piece of code (or its lexical environment) that called a given piece of code. Generally only known at run time.

CALLER::

A "pseudo-scope" to access "symbol"s in the "caller"'s "scope".

Camelia

The butterfly-like logo of Perl 6 as can be observed at http://perl6.org.

camelia

The "bot" on #perl6 channel that will evaluate code for you in various versions of Perl 5, Perl 6 and "NQP".

capture

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 : [...].

CAS

An atomic Compare And Swap. Primitive for lock-free multi-threaded read/write access.

category

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> { ... }

CFG

1) Context Free Grammar. 2) see "Control Flow Graph".

character

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.

channel

Short for "IRC" channel.

Or a concurrent queue.

christmas

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.

circularity saw

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.

circumfix

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>;
      # ^^^^^^^ circumfix

class

A basic software structure in "OOP". See the Wikipedia entry.

CLI

Command Line Interface, what you see in a Terminal (window).

clog

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.

Closure Parameter

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.

CLR

Common Language Runtime, as used by Niecza/mono/.NET.

codepoint

combining mark

comment

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.

compilation unit

A "compilation unit" is a set of files or a string that is compiled at once. It involves the "serialization" of code and data.

compile time

compiler

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

compiler constant

A "variable" with a ? "twigil". See http://design.perl6.org/S02.html#Twigils.and S24

COMPILING::

A "pseudo-scope" to access lexical "symbol"s in the "scope" being compiled.

composer

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

compunit

See "compilation unit".

concurrency

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.

concrete

An "object" "value" is concrete when it is not the "class" itself.

concrete syntax

container

context

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

context variable

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.

control flow

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.

Control Flow Graph

In "spesh", a "dominance" graph generated from "bytecode" analysis so that "Single Static Assignment" can be done.

constant

A "variable" that has an unchangeable "value".

constructor

The OO way to construct an object. Composers are constructor "Huffmanization"s that are available for the most common types like "pair"s.

CORE::

A "pseudo-scope" to access "symbol"s of the outermost lexical "scope", definition of standard Perl.

CPAN

Comprehensive Perl Archive Network. A content delivery system for Perl distributions.

credentials

CUR

Short for CompUnitRepo, the type of objects that inhabit @?INC.

CURL

Short for CompUnitRepo::Local, the type of CompUnitRepo objects that refer to the local file system.

cursor

D

dalek

An "IRC" "bot" that reports when various projects have been updated. It gives "karma" to those who pushed the changes to the project.

DarkPAN

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.

dead 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;
    }

debugger

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.

declarator

a "keyword" that introduces a "symbol" and defines its "scope" and "extent". Perl 6 declarators are "has", "my", "state", "our", respectively for /object , /lexical, </stateful|stateful variable> and /package. Also the "twigil" /* in the name of a package or lexical variable sets its extent to "dynamic".

destructuring

dev

Either a developer (person), or a development version of a program, or a branch for development in a repository.

DFS

Depth First Search. See also.

dies_ok

A Test function that succeeds when its argument, a Code object, dies at run time. See S24.

diffy

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.

DIHWIDT

"Doctor, It Hurts When I Do This." Well, stop doing it then.

dispatcher

The piece of code in the runtime that determines which (multi) method or subroutine to invoke.

distribution

A collection of 1 or more "compunit"s for installing locally, or for loading from a remote location.

DRY

Don't Repeat Yourself

DSL

"Domain specific language". See "slang".

Domain specific language

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

dominance

See "Control Flow Graph"

DYNAMIC::

A "pseudo-scope" to access contextual "symbol"s in my or any "caller"'s lexical "scope".

dynamic

dynamic language

dynamic typing

dynamic variable

the dynamic here is unrelated to the one in "dynamic typing". See "context variable".

DWIM

Acronym for "Do What I Mean". A programming language designer motto.

E

eager

One of the opposites of "lazy".

ecosystem

The ecosystem is a repository of Perl 6 modules installable by "Panda". "Rakudo *" releases include a tested subset of the ecosystem.

edsel

Something that intends to please everyone by catering for everybody's taste, yet in the end pleasing nobody, because nobody is catered for enough.

empty list

A list which contains no value. Denoted ().

EPIC FAIL

An internet expression describing the very dramatic, spectacular or just funny failure of an endeavor. See the relevant Wikipedia entry.

EVAL

A Perl 6 command that takes a string as an argument and executes its content as Perl 6 code.

exception

Exegesis

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

export

See "import".

EXPORT

Expression

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

extent

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.

Extop

An extension to the default "bytecode" "instruction set" in "Parrot" or "MoarVM". Used to support "opcode"s specific to a language.

F

FAIL

FAILBACK

when available in a class, called when all other attempts by the "dispatcher" have failed.

fat comma

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 => bar

fiddly

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

FIFO

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

flap

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.

first class entity

An entity that is accessible as a "value" during "runtime".

fork

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

FOSS

Free and Open-Source Software.

fossil

Something in a generally current document that is no longer true but which has not yet been fixed by correcting or removing it.

FP

Short for "functional programming"

frame

freenode

An "IRC" server that hosts "channel"s related to Perl 6 projects accessible through an IRC client at irc.freenode.org.

FSVO

For Some Value Of.

FTFY

Fixed That For You.

fudge

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.

functional programming

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.

G

GC

Garbage collecting.

gensym

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.

GIL

Global Interpreter Lock.

gimme

gist

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.

git

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.

git submodule

A way to use a git repositories from one git repository. More information/

github

Online open source repository hoster using "git". The /ecosystem is hosted on github.

given

Keyword for the Perl 6 switch "statement".

GLOBAL::

A "pseudo-scope" for "interpreter"-wide "package" "symbol"s, really UNIT::GLOBAL.

GLR

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.

golf

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.

golfing

The process of creating the shortest possible program to prove what you want. Sometimes also a form of "obfuscation".

good *

Good morning/afternoon/evening. Since the contributors are in many different timezones, one contributor's morning is another contributor's evening.

gorilla/banana problem

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

gradual typing

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.

grammar

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

grapheme

green threads

Threads that are scheduled by the virtual machine, not by the operating system.

grep

Command line utility to search text for lines matching a "regex". See http://en.wikipedia.org/wiki/Grep.

H

hash

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.

hash context

High Level Language

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.

HLL

See "High Level Language".

HN

Hacker news as seen on https://news.ycombinator.com.

HN'ed

Being mentioned on Hacker news (https://news.ycombinator.com).

HPMoR

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.

Huffmanization

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.

hyper

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.

hypothetical variable

hysterical raisins

Pun on historical reasons.

I

IC

I see.

iffy

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.

IIRC

If I Remember Correctly.

IIUC

If I Understand Correctly.

implementation

import

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.

infix

An operator that can appear between two terms, like the + in 40 + 2.

inline

install

installer

Int

A built-in arbitrary-sized integer type. See http://doc.perl6.org/type/Int.

int

interface

An interface is an "abstract class".

Intermediate Representation

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.

interpreter

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.

instruction set

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.

invocant

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 $_.

invokedynamic

An "opcode" that makes possible the support of /dynamic languages in "JVM". A presentation about invokedynamic.

IR

See "Intermediate Representation"

IRC

Internet Relay Chat. Perl 6 developers and users usually hang out on the "#perl6" "channel" on "freenode". See also http://perl6.org/community/irc.

ISTR

I Seem To Remember.

item

item context

Iterable

iteration

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

IWBN

It Would Be Nice.

J

jakudo

"Rakudo" running on the "JVM".

JAST

Intermediate representation of code used in the JVM backend of Rakudo and NQP.

JIT

Just-in-time compilation, a technique for improving the performance of virtual machines.

JSON

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

Junction

A compound type that is transparent to many operations. See http://doc.perl6.org/type/Junction.

JVM

Java Virtual Machine. The virtual machine for the Java programming language. Now many programming languages including Perl 6 have "compiler"s targeting the JVM.

K

karma

A measure of appreciation on "IRC". Example: "jnthn++ # moar commit"

keyword

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.

KISS

Keep It Simple, Stupid!, a famous motto in computer science.

L

lambda

An anonymous function. A block with explicit parameters: -> $a { say $a } The -> itself, or <-> for writeable parameter.

language

lazy

The property of a list not to evaluate elements until they are needed.

laziness

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 Perl6, 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

Lexical properties are derived from the structure of the source code itself, not from any information from run time.

lexical pad

A data structure that holds the values of lexical variables.

lexical scope

lexical symbol

lexing

lexotic

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.

lexpad

Short for "lexical pad".

LGTM

Looks good to me.

LHF

Low Hanging Fruit.

library

The compilation of a "compilation unit" of source code written in a non-dynamic language like C results in a library.

LIFO

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

line noise

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.

List

list context

lmddgtfy

Let Me DuckDuckGo That For You. http://lmddgtfy.net

LMGTFY

Let Me Google That For You. http://lmgtfy.com/

LoL

List of List

longname

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

LTA

Less Than Awesome.

LTM

See Longest Token Matching.

lvalue

M

machine code

Code specific to the "instruction set" of a hardware architecture. Compare with "bytecode".

magic variable

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.

MAIN

When present, a "multi"sub that is the entry point of a "program" "runtime". The code in "phaser"s intented to run at compile time are executed before MAIN. Like in Perl 5, a MAIN sub is not necessary.

MAST

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

Match

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.

match

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

memory

META.info

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.

metamodel

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

method

Methods are "sub"s that are called with an "invocant".

MI

Multiple inheritance.

mischan

A case of having put a message on the wrong (IRC) channel.

MMD

See "multi-method dispatch".

MoarVM

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.

modifier

It is a "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, c<:s>, c<:r> and :p5.

:g :ov :x :ex :pos

module

MOP

Meta-Object Protocol.

MRO

Method Resolution Order.

Mu

The mystical class from which all other classes are derived (無).

multi

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

multiple dispatch

Dynamically selecting which routine to execute based on name and type of arguments.

multi-method

multi-sub

multi-method dispatch

mumble

Placeholder; something that's left unclear deliberately. Either because the speaker doesn't know or because it's an unimportant detail.

my

MY::

A "pseudo-scope" to access "symbol"s in the current "lexical scope" (aka $?SCOPE).

N

named parameter

namespace

native

Something that does not pertain the Perl interpreter proper but to the "backend" or the underlying system. See also: "pure Perl"

Native Call

Native value

A native value is an "int", "num", "str". A native value cannot be undefined.

name

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

NCI

"Native Call" Interface

need

NFA

Nondeterministic Finite Automaton, an algorithmic technique used by the regex engine. See: https://en.wikipedia.org/wiki/Nondeterministic_finite_automaton.

NFG

Proposed "Unicode Normalization Form" for Perl6, 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.

Niecza

An implementation of Perl 6 targeting the .NET platform.

Nil

Means there is no value. This is different from (), the "empty list".

NST

No Such Thing.

nom

The name of the main branch of current "Rakudo" in "git". Originally named so for its "new object model".

Normalization Form

NPE

Null Pointer Exception.

null-PMC access

Num

number

numeric context

NQP

Short for Not Quite Perl, a subset of Perl 6 suitable for tasks such as implementing "Rakudo". Targets "Parrot", the "JVM" and "MoarVM".

NSA

Native, Shaped Arrays.

O

obfuscation

Code deliberately unreadable often using esoteric language features. Sometimes combined with "golfing".

object

object code

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.

On Stack Replacement

According to the hotspot glossary: The process of converting an interpreted (or less optimized) "stack frame" into a compiled (or more optimized) stack frame.

OO

Object oriented. See "OOP".

OOP

Acronym for Object-oriented programming.

op

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

opcode

An opcode is an instruction in a "bytecode" or "AST". Documentation about "MoarVM" opcodes.

open source

operand

See "operator".

operating system

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

opt

An optimization, usually in either the context of "spesh" or "JIT".

OS

Operating system. See http://en.wikipedia.org/wiki/Operating_system.

OSR

"On Stack Replacement"

our

OUR::

A "pseudo-scope" to access "symbol"s in the current package (aka $?PACKAGE).

OUTER::

A "pseudo-scope" to access "symbol"s in the next outer "lexical scope".

P

package

package manager

pad

See "lexical pad".

Pair

The simplest object containing a key and value pair.

pair notation

Way of expressing key/value pairs, using the "fat comma", creating a "Pair" object, for instance:

  foo => 1

Compare with the "adverbial pair" notation.

Panda

A Perl 6 program 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.

panda bootstrap script

parakudo

"Rakudo" running on "Parrot".

parameter

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.

parrakudo

See "parakudo".

PARENT::

A "pseudo-scope" to access lexical "symbol"s in the unit's DSL (usually CORE).

Parrot

A virtual machine designed to run Perl 6 and other "dynamic language"s. Mostly historic.

parser

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

parse tree

PAST

"Parrot" "AST".

PAUSE

Perl Authors Upload SErvice. The place where authors upload their distributions to "CPAN".

pb

Short for "problem". As in "that's not the pb".

PBP

"Perl Best Practices". The book by Damian Conway outlining best practices when programming Perl 5.

PDD

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.

Perlito

A "compiler" project that has frontends for Perl 5 and Perl 6, as well as multiple backends.

phaser

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

PIO

An implementation specific internal object for doing I/O. Originally a Parrot I/O object, now a Perl I/O object.

PIR

Parrot Intermediate Representation.

PMC

Parrot Magic Cookie.

pod

Plain Ol' Documentation, a documentation format understood by Perl 6. See S26 for details.

pod6

Used to specify Perl 6's version of "pod", as opposed to Perl 5's.

pointy block

See "lambda".

POLA

Principle Of Least Astonishment.

POLS

Principle Of Least Surprise.

Positional

A "role" denoting an linearly ordered composite data structure that can be iterated.

positional parameter

postcircumfix

An operator that follows a term directly and encloses another term inside it. For example:

    my $friend = @names[15];
    #                  ^--^ circumfix
    #            post--^

postfix

An operator that comes after the term it belongs to.

PPI

Perl 5 module for parsing, analyzing and manipulating Perl 5 source code. https://metacpan.org/pod/PPI.

pragma

A pragma is a module which influences some aspect of the compile time or run time behaviour of Perl.

precedence

The order in which operators bind terms together; tighter precedence evaluates before looser precedence. See "Operator precedence" in S03 for details.

prefix

An operator that comes before the term it belongs to, for example

    say ?42;    # True
    #   ^ prefix operator

predicate

expression used in a "boolean context" by a "control flow" "statement".

precomposed codepoint

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 codepoint) has its own dynamically assigned codepoint.

private

process

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.

PROCESS::

A "pseudo-scope" to access "process"-related globals (superglobals) "symbol"s.

producer

program

project

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.

pseudo-scope

pseudo-package

promise

proto

A proto is a generic "dispatcher" to "multi"s by the same "shortname".

proxy

PR

Short for "pull request".

prove

Perl 5 script to run tests through a "TAP" harness. See prove.

PSA

Problem, Solution, Acceptance.

PSGI

pull request

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.

pugs

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.

punctuational variable

Another name for "magic variable".

pun

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.

pure

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 /referential transparent giving the opportunity of optimizations.

pure perl

Use to qualify Some source code, or "project" that does not depend on non Perl resources like a "shared library" generated from C code.

p5

Short for Perl 5, the (older brother|parent) of Perl 6.

p6

Short for Perl 6, the (spunky little sister|child) of Perl 5.

P6W

See "Weekly Changes".

Q

QAST

Successor to "PAST".

queue

R

race

Process data asynchronously when possible, and don't care in which order the result data is returned.

Rakudo

An implementation of Perl 6 originally targeting "Parrot", it now targets Parrot, the "JVM", and "MoarVM" through "NQP".

Rakudo *

Rakudo Star, a useful and at most monthly, at least quarterly distribution of Rakudo which includes modules and "Panda".

R*

See "Rakudo *".

rakudobrew

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

Rakudo Star daily

Daily build reports on rakudo-star to track module tests on each "backend". Its README

rakudobug

A bug in "Rakudo". Usually used in contexts such as "/me submits rakudobug".

range

referential transparency

regex

Short for Regular Expressions, an easy way of parsing text for certain kinds of information.

regexp

An alternative abbreviation of "regex" that usually occurs in non-Perl 6 contexts.

reification

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

reify

REPL

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.

repository

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.

REPR

Representation.

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

Require is the "runtime" loading of a "module" and the related "import"s

revert

Revert is "git" terminology. It add new commit to revert the some changes in a branch. It is different from reset that thrpw away changes.

roast

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.

role

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

RPA

Resizable "PMC" Array.

RC

1) Release Candidate, a last chance to find terrible bugs or non-portabilities before the actual release.

2) "Rosetta Code"

3) Request Context.

Repository

Root Object

See root object. In "MoarVM", routines that handles roots are declared here.

Rosalind

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

Rosetta Code, a site for comparing snippets from different languages in how they solve various tasks.

RSN

Real Soon Now.

RT

Request Tracker (http://rt.perl.org/). To open a ticket, email> rakudobug@perl.org.

rule

runtime

S

sanity test

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.

say

SC

A "serialization context" groups together things, usually from the same "compilation unit".

scalar

scope

Association of a name with an entity delimited by a "block".

segfault

See "segmentation fault".

segmentation fault

Something that should never, ever happen. Complain on #perl6 if you see one.

self cloakng code

semicolon

A "character" used to separate or terminate "statement"s.

serialization

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.

serialization context

SETTING::

A "pseudo-scope" to access "lexical symbol"s in the unit's "DSL" (usually CORE).

setting

Library set that is loaded by default. When possible, the setting is loaded lazily to optimize loading time.

shared library

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

shortname

The name of a routine only; without the type signature of its invocant arguments. See "longname".

sigil

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.

signature

A signature is used by "block"s, "sub"s or "methods" in L to specify the "arguments" they can receive when they are called.

Single Static Assignment

sink context

Context of an expression whose value is ignored. Often called "void" context in other languages.

sixplanet

sixplanet is a collation of blogs related to Perl 6. If planeteria.org is down, a replacement can be found on http://pl6anet.org/.

slang

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

smart match

SMOP

Small/Simple Matter Of Programming. The thing you do when not specifying, documenting, discussing, lurking or idling. See also here.

slurpy

A parameter that will "slurp up" any excess named or positional parameters and present them as a hash or list respectively.

slushy

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.

source code

spectest

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.

special variable

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.

spesh

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.

splat

SSA

See "Single Static Assignment".

stack frame

See "frame".

STable

Representation independent data structure associated with the type of an object. Part of the "6model". See http://jnthn.net/papers/2013-yapceu-moarvm.pdf.

stage

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 availabe, 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.

star

See "Rakudo *".

stash

state

statement

static frame

Data pertaining to a "frame" gathered at compile time.

static typing

In a language with stating typing, at "runtime", values don't need to be annotated with their type. See "type erasure".

Compare with "dynamoc typing", "gradual typing"

STM

Software Transactional Memory.

Str

Name of the string type.

string

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.

sub

Short for subroutine.

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.

Subsignature

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.

supply

symbol

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.

:sym

Synopsis

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.

syntax analysis

See "parser".

Syntax sugar

See "Huffmanization".

synthetic codepoint

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.

T

tail call

TAP

Test Anything Protocol.

Task::Star

A "bundle" that directs "Panda" to install "Rakudo *" "module"s.

TCO

"tail call" optimization.

term

test suite

The Perl 6 test suite is "roast"

Texas operator

The ASCII variant of a non-ASCII Unicode operator or symbol. So described because "Everything's bigger in Texas." For instance, >>+<< is the "Texas" form of the »+« hyper-addition operator, and (elem) corresponds to the ("Is this an element of that set?") operator that comes from set theory. Texas 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...

TheDamian

"IRC" screen name for Damian Conway, writer of the original Exegeses.

thinko

A thinkographical error; i.e. a small mistake made by improperly expecting code to "DWIM" or from an interrupted thought process.

thread

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.

thunk

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

TimToady

"IRC" screen name for Larry Wall, creator of Perl. The name comes from the pronunciation of "TMTOWTDI" as a word.

TIMTOWTDI

An alternative form of "TMTOWTDI", explicitly including the "is" from the contraction "There's".

tl;dr

Too Long; Didn't Read. Also denotes a summary for those who are prone to claim tl;dr.

TMI

Too Much Information.

TMTOWTDI

"There's More Than One Way To Do It", the Perl motto.

token

A token is a keyword that introduces a lexing "rule" in a grammar

topic

Expression whose value is aliased to $_.

trait

TTIAR

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

tpyo

Typo.

tuit

The mystical unit of effort in the open source community. Sometimes materialized in wooden nickels.

twigil

A secondary "sigil". For example, %*ENV has a sigil of % and a twigil of *.

See http://design.perl6.org/S02.html#Twigils.and S24

type

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 erasure

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.

U

UAX

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.

UCD

See "Unicode Character Database".

unboxing

See "boxing".

unspace

A way to put "whitespace" in your code that is ignored by the parser. Introduced with a backslash.

ufo

See here.

UGT

"Universal Greeting Time" - i.e., it's always "morning".

unary

An operator is unary if its "arity" is one. Operators belonging to the categories "prefix", "postfix" and "circumfix" are unary.

Unicode

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.

Unicode Character Database

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.

Unicode Normalization Form

See "UAX" 15. Perl 6 defines an additional one : "NFG".

unit

See "compilation unit".

UNIT

Symbols in the outermost lexical scope of a compilation unit.

unslushing

See "slushy".

use

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

V

value

variable

A variable is a name for a "container".

variable interpolation

See "sigil" and "Q forms" in S02.

variadic

ver

Short way to indicate "version".

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

Strangely the "NQP" related information is missing.

visibility

An "object variable" declared with the ! "twigil" can be in scope but is not visible.

Virtual Machine

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

VM

See "Virtual Machine".

v5

Stands for "Perl, version 5" and is used in code to indicate that the code is Perl 5:

    use v5;

v6

Stands for "Perl, version 6" and is used in code to indicate that the code is written in Perl 6:

    use v6;

W

warnocked

This lemma will never be explained.

WAT

https://www.destroyallsoftware.com/talks/wat. Often used as the opposite of "DWIM".

Weekly Changes

Mostly weekly report about changes in the Perl 6 World. See also: "sixplanet".

wfm

Works For Me.

Whatever

http://doc.perl6.org/type/Whatever.

whitespace

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

WIP

Work In Progress.

world

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.

WP

Wikipedia.

ww

Short for wrong window. When on IRC, someone types something in a channel that was intended for another channel, or for a private message.

X

XY Problem

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.

Y

YAPAE

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.

yoleaux

The "bot" on #perl6 that is your personal assistant. See https://github.com/dpk/yoleaux and http://dpk.io/yoleaux.

YOU_ARE_HERE

Z

Zavolaj

Zavolaj was a module to support "native call"s into libraries. It is now part of "Rakudo"

Zen slice

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

#perl6

"IRC" "channel" on "freenode" that hosts discussions related to Perl 6. Archived on http://irclog.perlgeek.de/perl6/.

.

..

...

:

Everybody wants the colon.

:ignorecase

:ignoremark

:ratchet

?

(

()

See "empty list".

*

Oh, um... "Whatever".

@_

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&

6model

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.

AUTHORS

    Elizabeth Mattijsen (liz@dijkmat.nl)
    Moritz Lenz
    Larry Wall

POD ERRORS

Hey! The above document had some coding errors, which are explained below:

Around line 920:

alternative text '/object' contains non-escaped | or /

alternative text '/lexical' contains non-escaped | or /

alternative text '/package' contains non-escaped | or /

Around line 2884:

alternative text '/synthetic codepoint' contains non-escaped | or /

Around line 3013:

alternative text '/referential transparent' contains non-escaped | or /

[ Top ]   [ Index of Synopses ]