This page was generated by Text::SmartLinks v0.01 at 2014-11-27 18:01:07 GMT.
(syn 96eb086)
  [ Index of Synopses ]

TITLE

Synopsis 99: Glossary

VERSION

    Created: 26 June 2013
    Last Modified: 18 Aug 2014
    Version: 7

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 knowledgable will add the explanation later for you and everybody else.

A

ack

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

Also used by old folks to indicated 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 noone 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 "operands" 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 a algorithm. Here, backtracking usually meains moving back the "cursor". In a non greedy match, it means moving the cursor forward.

backend

Denote a VM targetted 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

An non quoted alphanumeric string. In Perl 6, only allowd 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. Used for "control flow" and as "scope".

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 repective 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 booststrapping the "6model" of MoarVM

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.

Bug report

The way to report problems to the implementors. For the interpretors 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.

bytecode

C

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 IRC-bot on #perl6 that will evaluate code for you in various version 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 counterpard 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 "long name". That includes the signature but also the value of the :sym adverb. An expression is constituted of tokens that belongs 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".

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

CLR

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

comment

Parts of a program intend for user consumption that are not used to generate code. Beside the # that starts a comment that ends 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 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 generate 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 an "compilation unit". Then, this bytecode is executed. Depending on the type of the data manipulated by the "program" bytecode can be transformed in optimised bytecode or into "machine code". This last two operations are forms of "JIT".

COMPILING::

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

composer

A composer is a syntax for defining "values". 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

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 hash context. Some "prefix" "operator"s are used to force the context;

control flow

Without control flow statements, a program execution would be purely sequential. Control flow statement generally uses a predicate and branches to one of its subtatement 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 a unchangeable "value".

constructor

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

CORE::

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

CPAN

Comprehensive Perl Archive Network. 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.

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.

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.

DSL

"Domain Specific Language". See "slang".

Domain specific language.

Dominance

See "Control Flow Graph"

DYNAMIC::

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

dynamic

dynamic language

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

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.

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

Extop

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

F

FAIL

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.

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

fossil

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

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.

G

GC

Garbage collecting.

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

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.

green threads

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

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.

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 to express specific semantics proper to a given "OO" language. "Zavolaj" provides interoperabiity 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

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.

import

"Module"s interact with each other through named entities called symbols. The operation that makes symbols from a module avalaible 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.

inline

install

installer

Int

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

int

interface

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 a that is transformeed to an "AST"s Sometimes the information can be regenerated from the bytecode. In rakudo the Single Static Assignment form is inferred from the bytecode.

interpreter

invocant

A "method" has generally one invocant by 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

A "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 irc.freenode.org. See also http://perl6.org/community/irc.

ISTR

I Seem To Remember.

item

item context

iteration

A way to go thru 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 performance of virtual machines.

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 "compilers" that targets the JVM.

K

karma

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

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.

lazy

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

laziness

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.

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.

LHF

Low Hanging Fruit.

Library

The compilation of a "compilation unit" of source code written in 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 "stack". See also "FIFO".

List

lmddgtfy

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

LMGTFY

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

LoL

List of List

LTA

Less Than Awesome.

LTM

See Longest Token Matching

M

machine code

Code specific to the "instruction set" of an 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 implicitely defined at the beginning of each block.

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

See also "parse".

metamodel

The metamodel describe some OO behaviors, like where to find a "method". This permits to implement differnent 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.

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

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 Call

Native value

A native value is a "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".

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

null-PMC access

Num

number

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

opcode

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

open source

operand

See "operator".

operator

An expression is made of operators and operands. More precisely it is made of an operator and operands that can be subexpressions or "values". 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, can be "fidly", "iffy", "diffy". Perl 6 is very creative as to what is an operator so they are many categories which operators are amde of many tokens, possibly with a subexpression. For example, @a[0] belongs to the postcircumfix category is broken in the operand @a and the postcircumfix operator [0] where 0 is 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> specifies to call .ternary to posprocess the parse subtree and :pasttype<if> specify 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".

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

In contrast 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 medadata files of said modules. Unlike other "package manager"s, panda supports many "VM"s, that is 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, a "NFA" based engine. "LTM" is a feature of the NFA engine. One difference between | and || is that the former involves a NFA, while the latter involves the recursive engine. That's why the former is faster than the latter.

parse tree

PAST

Parrot "AST".

PAUSE

Perl Authors Upload SErvice. The place where author 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, and 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 al regular code has run (END).

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

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

pseudo-scope

pseudo-package

proto

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.

pure

A function or method is pure if it has no side effect

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.

Q

QAST

Successor to "PAST".

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

rakudobug

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

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. Usuallly Perl 6 related information are stored in "github" repositories. The official list of Perl 6 modules is the "ecosystem" is also stored in a repository. When installing a module, the "panda" "package manager" uses the ecosystem to fetch the appropriate repositories for transitive dependancies.

REPR

Representation

Representation

In MoarVM, low level C code associated to a data type. Typically a nqp call for a type translates into a moarvm instruction (opcode) that calls a function in the representation table of that type.

require

revert

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.

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.

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.

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

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 expression starting with such a variable.

Single Static Assignment

sink context

"Context" of an expression which value is ignored.

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 "action"s. 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 /NFAs table but 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

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

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 suit. See also: "ROASt".

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 independant datastructure associated to the type of an object. Part of the "6model". See http://jnthn.net/papers/2013-yapceu-moarvm.pdf.

star

See "Rakudo *".

stash

statement

Static frame

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

STM

Software Transactional Memory

Str

Name of the string type.

sub

Short for subroutine

Subroutine

symbol

Fancy alternative way to denote a name. Generally used in the context of modules linking, be it in the "OS" level, or at the Perl 6 "VM" level for modules generated from languages targetting these VMs. The set of imported or exported symbols is called the symbol table.

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.

Syntax sugar

see "Huffmanization".

T

TAP

Test Anything Protocol

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 to parallelize 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

In parsing theory, the parsed string is broken into tokens that are the input of "syntax analysis". In Perl 6, things are not so clear cut and the two conceptual phases are defined by the "grammar"

topic

Expression which 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://perlcabal.org/syn/S02.html#Twigils.

U

UAX

Unicode Standard Annex. Unicode standard material that is not part of the core. Some are specific to some languages while other are generic, like UAX 15 that 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", "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 Data Base

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 addtional one : "NFG".

unit

See "compilation unit".

UNIT

Symbols in the outermost lexical scope of compilation unit

unslushing

See "slushy".

use

V

value

variable

A variable is a name for a "container".

variable interpolation

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

ver

Short way to indicate "version".

version

Can be obtained with perl6 -v with perl6 depending on your "implementation". This command gives something like 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.

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

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

yoleaux

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

Z

Zavolaj

/Zavolaj is a module to support native calls into libraries

*

Oh, um... "Whatever".

.

..

...

:

Everybody wants the colon.

?

(

()

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

%_

++

Way to increase "karma" on IRC.

&

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
[ Top ]   [ Index of Synopses ]