/S99-glossary.pod

=encoding utf8

=head1 TITLE

Synopsis 99: Glossary

=head1 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 L</apocalypse> or L</exegesis
predecessor>.  It is intended as both a quick introduction to terms
used on the L</#perl6> L</channel> on L</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.

=head1 A

=head2 Abstract class

An abstract L</class> defines the L</interface> of a class. Its L</method>s are left
undefined. In Perl 6, abstract classes is one of the related abstractions implemented as
L</role>s.

=head2 ack

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

Also used by old folks to indicate acknowledgement.

=head2 actions

A class used to generate an L</AST> from the results of parsing text with a
L</grammar>. The method to attach a generated AST is called "make", to retrieve
an AST you can call "made" or "ast".  See L<S05-regex/Action objects>.

=head2 advent calendar

Articles about Perl 6 for every days of December before Christmas.
At L<https://perl6advent.wordpress.com/>.


=head2 adverb

See L<adverbial pair>.

=head2 adverbial pair

A generalized form of L</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

=head2 AFAICS

As Far As I Can See.

=head2 AFAICT

As Far As I Can Tell.

=head2 AFAIK

As Far As I Know.

=head2 afk

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

=head2 ALAP

As Late As Possible

=head2 Any

The class from which most things derive, except for L</Junction>s.
Any is derived from L</Mu>.

=head2 any()

A Junction with "or" semantics.

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

=head2 Apocalypse

A document originally written by L</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 L</Exegesis> and
L</Synopsis>.

=head2 arity

Number of L</operand>s expected by an L</operator>.

=head2 argument

=head2 array

=head2 AST

Acronym for
L<B<A>bstract B<S>yntax B<T>ree|http://en.wikipedia.org/wiki/Abstract_syntax_tree>.
Used in many places, including L</actions>, L</PAST>, and L</QAST>.

=head2 atomic

See L</CAS>.

=head2 attribute

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

=head2 auth

Way of deliberately ambiguously expressing L</author> or L</authority>.

=head2 author

=head2 authority

=head2 autopun

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

=head1 B

=head2 backlog

That part of a discussion on an L</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 L<http://irc.perl6.org> to see what has been logged for you.

=head2 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 L</cursor>. In a non-greedy match, it means moving the cursor
forward.

=head2 backend

Denote a VM targeted by L</Rakudo>. Can be L</MoarVM>, L</JVM> or
L</Parrot>.

=head2 Bailador

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

=head2 bare string

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

=head2 biab

Back In A Bit.  Only L</afk> for a little while.

=head2 binary

An operator is binary or of L</arity> two if its L</category> is L</infix>
or L</postcircumfix>.

=head2 blast

"B<Bl>ock, B<A>lternatively B<St>atement". Several constructs in Perl 6
expect either a single L</statement>, or a L</block>. Thus, a blast:

    try { dangerous(); functions() };
    #   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^  Block
    try dangerous-function();
    #   ^^^^^^^^^^^^^^^^^^^^          Statement

Particularly cute, because L</phaser>s expect blasts.

=head2 block

A source code section delimited by braces and may have an explicit L</signature>.
Used for L</control flow> and as L</scope>.
A L</return> in a block returns from the enclosing L<subroutine>.
A block is a L</first class entity> which makes it useful for L<functional programming>.

=head2 blorst

"B<Bl>ock, B<OR> B<St>atement".  Different way to say L</blast>.

=head2 Bool

L<Boolean|/boolean> type.

=head2 boolean

L<Value|/value> of type L</Bool>. Apart the class itself, can be either
C<True> or C<False>.

=head2 boolean context

A L</context> that forces an L<expression|/Expression> to give a L</boolean>
value.  The L</prefix> L</operator>s C<so>, C<not> and their respective
higher L</precedence> C<?> and C<!> forms force a boolean context with C<!>
and C<not> doing a negation.  The L</predicate> part of a L</control flow>
L</statement> forces a boolean context.  A class can define a C<Bool> method
to handle the boolean context.  For L<natives|/"Native value">, within
L</MoarVM>, it is handled by C</MVMBoolificationSpec> member of the
L</STable> structure.

=head2 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.
L<Documentation|https://github.com/MoarVM/MoarVM/blob/master/docs/bootstrap.markdown>
about bootstrapping the L</6model> of L<MoarVM>

=head2 bot

A program that does automatic tasks on one or more L</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. L</camelia>, L</dalek> and L</yoleaux>
are bots on the L</#perl6> channel.

=head2 boxing

Operation transforming a L<native value|/"Native value"> into an object.
The reverse operation is unboxing.  The relation between boxed/native should
not be confused with L</container>/containee.

=head2 branch

=head2 brb

Be Right Back.  Only L</afk> for a little while.

=head2 BS

Bounded Serialization.

=head2 BSON

BSON is the binary counterpart to the textual L</JSON> data format.
Used by Mongodb and supported by the
L<MARTIMM/BSON|https://github.com/MARTIMM/BSON/> L</project>.

=head2 Bug report

The way to report problems to the implementors.  For the interpreters
themselves, use L</RT>.  It is good practice to include the interpreter
L</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 L</golfing> For the user packages hosted on
L</github>, you can report issues.

=head2 bundle

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

=head2 bytecode

Bytecode is to a L</Virtual Machine> what L</machine code> is to a CPU
but, unlike machine code, is portable.  From L</source code> L</Rakudo>
can generate bytecode for the L</JVM> and L</MoarVM> virtual machines.
When executing a script, rakudo does not need to compile the used
L</module>s because they should already be available as bytecode
installed by L<Panda>.


=head1 C

=head2 callable

=head2 caller

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

=head2 CALLER::

A L</pseudo-scope> to access L</symbol>s in the L</caller>'s L</scope>.

=head2 camel case

A naming convention where a word boundaries in a multiple word identifier is
indicated with medial capitalization.  For example, "isDeeply".  Popular in
Java, C++, C#, and Visual Basic.

See L</kebab case>, L</snake case>.

=head2 Camelia

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

=head2 camelia

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

=head2 capture

A regex can record substrings of the L</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
    }

C<(I<...>)> is the capture syntax while its non-capturing counterpart is the
grouping syntax : C<[I<...>]>.

=head2 CAS

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

=head2 category

In L</grammar>s, regex of a L</multi> form a category that are distinguished
by their L</longname>. That includes the L<signature> but also the value of
the L</:sym> adverb. An L<expression|/Expression> consists of tokens that
belong either in the category L</term> or one of the L</operator>'s
categories.

A regex definition for one of the term kinds :

    token term:sym<name> { ... }

=head2 CFG

1) Context Free Grammar.
2) see L</Control Flow Graph>.

=head2 character

A L</string> is a sequence of characters.  Like in Perl 5, there is no
character type in Perl 6 so when someone says a I<character> about a
L</value>, he means a string with one character. In L</Unicode> a
character is called a L</grapheme> and may be composed of many L</codepoints>.
But a string represented in the L</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 L<.bytes>, L<.codes>,
L<.chars>.

=head2 channel

Short for L</IRC> channel.

Or a concurrent queue.

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

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

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

=head2 class

A basic software structure in L</OOP>.
See the L<Wikipedia entry|http://en.wikipedia.org/wiki/Class_%28computer_programming%29>.

=head2 CLI

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

=head2 clog

To L</backlog>.

Etymology: There is a website C<irclog.perlgeek.de> providing either IRC
logs or IR clogs, depending on how you interpret the domain name.

=head2 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 C<Str> as their argument:

    sub call-me(&callback:(Str)) { ... }

Not to be mistaken for L<Subsignatures|/Subsignature>.

See also L<S06-routines/Closure parameters>.

=head2 CLR

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

=head2 codepoint

=head2 combining mark

=head2 comment

Parts of a program intended for user consumption that are not used to
generate code.  Beside the C<#> 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 L</whitespace>, or
comments that appear after a name declaration that are included in the
L</pod> documentation.

=head2 compilation unit

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

=head2 compile time

=head2 compiler

In a L</dynamic language> like Perl 6, the compiler is also referred to as
L</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 L</concrete syntax> to L</bytecode>, the first conceptual
phase is called L<parsing|/parse> and generates a L</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 L</bytecode> in a
L</compilation unit>.  Then, this bytecode is executed. Depending on the
type of the data manipulated by the L</program>, bytecode can be transformed
into optimised bytecode or into L</machine code>.  These last two operations
are forms of L</JIT>.

=head2 compiler constant

A L</variable> with a C<?> L</twigil>.
See L<http://design.perl6.org/S02.html#Twigils> and L<S24|http://design.perl6.org/S24.html>.

=head2 COMPILING::

A L</pseudo-scope> to access lexical L</symbol>s in the L</scope> being
compiled.

=head2 composer

A composer is a syntax for defining L</value>s. When values are L</object>s,
their composer is a L</Huffmanization> of a L</constructor>
L<expression|/Expression>. For an example, see the L</fat comma>.

=head2 compunit

See L</compilation unit>.

=head2 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 L</process>es or
L</thread>s. Collaboration involves synchronization primitives
likes mutexes, locks, semaphores.  Perl 6 provides high level
abstractions like L</feed>s, L</junction>s, L</hyperoperator>s,
L</promise>s, L</channels> so that the programmer is usually spared
the explicit use of threads and the endless problems they involve.

Compare with L</parallelism>.
See L<S17-concurrency>.

=head2 concrete

An L</object> L</value> is concrete when it is not the L</class> itself.

=head2 concrete syntax

=head2 container

=head2 context

A context specifies the kind of value expected from an L<expression|/Expression>.
A context may be L</boolean context>, L</numeric context>, L</item context>,
L</list context> or L</hash context>.
Some L</prefix> L</operator>s are used to force the context.

Context is also information that can affect parsing

=head2 context variable

A L</variable> with a C<*> L</twigil>.  Used to set up contextual
information that can be shadowed by calls deeper in the L</call
stack>.  Heavily used in the Perl 6 compiler because Perl 6 is a very
contextual language, so gathered information affects the parsing. See
L</keyword> for an example.

See also L</lexotic>, L<http://design.perl6.org/S02.html#Twigils> and
L<S24|http://design.perl6.org/S24.html>.  Also called dynamic
variable.

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

=head2 Control Flow Graph

In L</spesh>, a L</dominance> graph generated from L</bytecode> analysis so
that L</Single Static Assignment> can be done.

=head2 constant

A L</variable> that has an unchangeable L</value>.

=head2 constructor

The OO way to I<construct> an object. L<Composer>s are constructor
L</Huffmanization>s that are available for the most common types like
L</pair>s.

=head2 CORE::

A L</pseudo-scope> to access L</symbol>s of the outermost lexical L</scope>,
definition of standard Perl.

=head2 CPAN

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

=head2 credentials

=head2 CUR

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

=head2 CURL

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

=head2 CURLI

Short for C<CompUnitRepo::Local::Installation>.

=head2 cursor

=head1 D

=head2 dalek

An L</IRC> L</bot> that reports when various projects have been updated. It
used to give L</karma> to those who pushed the changes to the project.

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

=head2 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;
    }

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

=head2 declarator

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

=head2 destructuring

=head2 dev

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

=head2 DFS

Depth First Search. See L<also|http://xkcd.com/761/>.

=head2 dies_ok

A C<Test> function that succeeds when its argument, a Code object, dies at
run time. See L<S24|http://design.perl6.org/S24.html>.

=head2 diffy

An L</operator> that produces a resulting L</value> of a L</type> different
from its L</argument>s. For example, all the comparison operators like C<==>
and C<lt> are diffy (because they produce C<Bool>s), the range operators are
diffy (because they produce ranges), but C<+> and C<~> and C<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 C<[+]> makes sense, but C<[..]>
doesn't.  (C<[==]> 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 C<+=> makes sense, but C<..=>
doesn't.

=head2 DIHWIDT

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

=head2 dispatcher

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

=head2 distribution

A collection of 1 or more L</compunit>s for installing locally, or for
loading from a remote location.

=head2 DRY

Don't Repeat Yourself

=head2 DSL

L</Domain specific language>. See L</slang>.

=head2 Domain specific language

A special-purpose language used for a particular problem domain. For
instance, some web frameworks (such as L<Dancer|http://perldancer.org/>) 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
L<https://en.wikipedia.org/wiki/Domain-specific_language>

=head2 dominance

See L</Control Flow Graph>

=head2 DYNAMIC::

A L</pseudo-scope> to access contextual L</symbol>s in my or any
L</caller>'s lexical L</scope>.

=head2 dynamic

=head2 dynamic language

=head2 dynamic typing

=head2 dynamic variable

the dynamic here is unrelated to the one in L</dynamic typing>.
See L</context variable>.

=head2 DWIM

Acronym for "B<D>o B<W>hat B<I> B<M>ean".  A programming language designer
motto.

=head1 E

=head2 eager

One of the opposites of L</lazy>.

=head2 ecosystem

The L<ecosystem|https://github.com/perl6/ecosystem> is a repository of Perl
6 modules installable by L</Panda>. L</Rakudo *> releases include a tested
subset of the ecosystem.

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

=head2 empty list

A list which contains no value. Denoted C<()>.

=head2 EPIC FAIL

An internet expression describing the very dramatic, spectacular or just funny failure of an endeavor.
See the L<relevant Wikipedia entry|https://en.wikipedia.org/wiki/Failure#Internet_memes>.

=head2 EVAL

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

=head2 exception

=head2 Exegesis

A document originally written by L</TheDamian>, in which he tried to explain
the L</Apocalypse>s to the common (wo)man.  Now only kept as an historical
document for reference.  See also L</Synopsis>.

=head2 export

See L</import>.

=head2 EXPORT

=head2 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 L</context>.  An expression is all or part of a L</statement>.

=head2 extent

The extent is the interval of time a L</first class> entity lives.  The
extent is different from the L</scope> of a name.
A L</lexical variable> can be still alive when its name is out of scope if
some reference still exists.

=head2 Extop

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

=head1 F

=head2 FAIL

=head2 FAILBACK

when available in a class, called when all other attempts by the
L</dispatcher> have failed.

=head2 fat comma

Contrary to Perl 5, C<< => >>, the fat comma does not simply separate two
values but makes a L</Pair> out of them. The left value can be a L</bare
string>. This is the only place where Perl 6 accepts a bare string. Example:

      foo => bar

=head2 fiddly

Used of an L</operator> that doesn't participate in forming metaoperators at
all.  (Because that would be "too fiddly" to get to work, presumably.) C<??
!!> is such an operator. The method call operator is another. (And hence
C<.=> 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.

=head2 FIFO

L<First In First Out|https://en.wikipedia.org/wiki/FIFO>, a fairly common
data structure in programming languages.  In Perl 6 an array behaves as such
when used as a L</queue>.  See also L</LIFO>.

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

=head2 first class entity

An entity that is accessible as a L</value> during L</runtime>.

=head2 fork

The creation of another process.

Also, a feature of L</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 L</pull request>.

=head2 FOSS

Free and Open-Source Software.

=head2 fossil

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

=head2 FP

Short for L</functional programming>

=head2 frame

=head2 freenode

An L</IRC> server that hosts L</channel>s related to Perl 6 projects accessible
through an IRC client at C<irc.freenode.org>.

=head2 FSVO

For Some Value Of.

=head2 FTFY

Fixed That For You.

=head2 fudge

Way to temporarily mark tests in the L</spectest> for a specific Perl 6
version as I<todo> (so that a failure of the test will be marked ok, and a
pass will be marked as an exception), or as I<skip> if they cause a
L</compile time> or L</runtime> exception.

=head2 functional programming

A programming style that mostly or exclusively relies on functions, L</pure>
or not.  Perl 6 supports functional programming but does not force it on
you.

=head1 G

=head2 GC

Garbage collecting.

=head2 gensym

A B<gen>erated B<sym>bol. Used primarily in L</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
L</symbol>s `#:G847`, `#:G848` and `#:G850` below from
L<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.

=head2 GIL

L<Global Interpreter Lock|https://en.wikipedia.org/wiki/Global_Interpreter_Lock>.

=head2 gimme

=head2 gist

A summary, or a method on objects that is invoked by L</say> to print out
the object in a human readable format.

Or a paste server with L</git> capabilities used by denizens of
L</IRC>. See L<https://gist.github.com> for the last usage.

=head2 git

The distributed source revision system used by many, if not all Perl 6
projects, generally hosted on L</github>. A good
L<glossary|https://www.kernel.org/pub/software/scm/git/docs/gitglossary.html>
about git.  A good L<reference|http://git-scm.com/book>.

=head2 git submodule

A way to use a git L<repositories|/repository> from one git repository.
L<More information|http://git-scm.com/book/en/Git-Tools-Submodules>

=head2 github

Online open source repository hoster using L</git>.  The L</ecosystem> is
hosted on github.

=head2 given

Keyword for the Perl 6 switch L</statement>.

=head2 GLOBAL::

A L</pseudo-scope> for L</interpreter>-wide L</package> L</symbol>s, really
UNIT::GLOBAL.

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

=head2 GLRR

Further Refinement of the L</GLR>.

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

=head2 golfing

The process of creating the shortest possible program to prove what you
want.  Sometimes also a form of L</obfuscation>.

=head2 good *

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

=head2 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 L</OO> inheritance based environment inflexibility.  In non
L</dynamic language>s, you can't dynamically add L</attribute>s/L</method>s
for an L</object>/L</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 L</role>s that group methods or attributes. A role can be
dynamically added to a class or an object.

=head2 gradual typing

According to wikipedia I<Gradual typing is a type system in which
variables may be typed either at compile-time (which is L</static typing>)
or at L</runtime> (which is L</dynamic typing>)>.
Perl 6 supports gradual typing.


=head2 grammar

A feature of Perl 6 that uses L</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
L</actions>.  A grammar is composed of methods introduced by one of the
three keywords C<rule>, C<L</token>>, C<regex>. There is L</backtrack>ing
only in C<regex> and C<rule> implies L</whitespace>s between subrules.

Parsing is done conceptually in two phases, L<lexing> and L<syntax
analysis>.  Lexing breaks the input string in tokens that are the
input of L<syntax analysis|/Syntax analysis>. In Perl 6, things are
not so clear cut and both phases are defined in the L</grammar>.


=head2 grapheme

=head2 green threads

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

=head2 grep

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

=head1 H

=head2 hash

A data type, conveniently available in variables starting with the percent
sign C<%> and provided by types conformant to the C<Associative> role like
the C<Hash> type.  Often called associative table in other languages.

=head2 hash context

=head2 heap

Dynamically allocated memory pool used for memory management. Unused parts are reclaimed
by the L</GC>. See L<Memory management|https://en.wikipedia.org/wiki/Memory_management#DYNAMIC>.

=head2 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 L</representation>s may differ.  Also,
a given language may provide many flavors of them.  Perl 6 provides common
L</concrete syntax> to access them.  C<MVMHLLConfig> is the L</MoarVM> C
level structure that hooks to the underlying language specific
representations.  The L</metamodel> allows one to express specific semantics
proper to a given L</OO> language.  L</Rakudo> provides interoperability
with languages which compilers follow C language linking conventions.

=head2 HLL

See L</High Level Language>.

=head2 HN

Hacker news as seen on L<https://news.ycombinator.com>.

=head2 HN'ed

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

=head2 HOW

Higher Order Workings.  Also the name of the method you can call on
B<any> object to find out the meta-class of that object (of which the
type object of an object is the instantiation).

=head2 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 L<http://hpmor.com>.

=head2 Huffmanization

L<Huffman coding|http://en.wikipedia.org/wiki/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, L</composer>s are a form of huffmanization.

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

=head2 hypothetical variable

=head2 hysterical raisins

Pun on historical reasons.

=head1 I

=head2 IC

I see.

=head2 iffy

Used of an operator that either returns a C<Bool> result, I<or something
like it> (such as a match object). All the comparison operators are iffy, as
are conditional operators like C<&&>, C<?^>, and C<or>. C<%%> is iffy, but
C<%> isn't. The junctive operators are iffy.

The reason that we care about iffy operators is that you can only append the
C<!> metaoperator to an operator that's iffy.

=head2 IIRC

If I Remember Correctly.

=head2 IIUC

If I Understand Correctly.

=head2 implementation

=head2 import

L<Module|/module>s 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.

=head2 infix

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

=head2 inline

=head2 install

=head2 installer

=head2 Int

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

=head2 int

=head2 interface

An interface is an L</abstract class>.

=head2 Intermediate Representation

In a compiler, Intermediate data structures that are generated from the
L</source code> to generate L</object code> or L</bytecode>.  In L</Rakudo>
: L</parse tree>, and L<Abstract Syntax Tree|/AST>.  The L</parser>
generates an IR that is transformed to an L</AST>.  Sometimes the
information can be regenerated from the bytecode.  In Rakudo the L</Single
Static Assignment> form is inferred from the bytecode.

=head2 interpreter

An interpreter is the entity that executes L</bytecode> generated from
L</source code> in a given L</language>.  It relies on the underlying
L</VM>. It may load L<extops>, that is bytecode L</ops> that are
specific to the said language.


=head2 instruction set

An instruction set is a set of instructions specific to a L</bytecode>
or a microprocessor.  Also L</NQP> defines an instruction set. Its
opcodes are documented in
L<ops.markdown|https://github.com/perl6/nqp/blob/master/docs/ops.markdown>.

=head2 invocant

A L</method> has generally one invocant but may have many according to its
L</signature>.  As a L<parameter>(s), the parameters before the C<;>.  As an
L<argument>, the left L</operand> of the C<.> L</operator>.  In the
L<expression|/Expression> C<42.say>, C<42> is the invocant.  When missing,
like in C<.say>, the invocant is C<$_>.

=head2 invokedynamic

An L</opcode> that makes possible the support of L</dynamic language>s in
L</JVM>.  A L<presentation|http://www.infoq.com/presentations/invokedynamic>
about invokedynamic.

=head2 IR

See L</Intermediate Representation>

=head2 IRC

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

=head2 ISTR

I Seem To Remember.

=head2 item

=head2 item context

=head2 Iterable

=head2 iteration

A way to go through all the values of an L</Iterable> object like a L</list>
or a L</hash>.  Generally, iterator L</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

=head2 IWBN

It Would Be Nice.

=head1 J

=head2 jakudo

L</Rakudo> running on the L</JVM>.

=head2 JAST

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

=head2 JIT

L<Just-in-time compilation|https://en.wikipedia.org/wiki/Just-in-time_compilation>,
a technique for improving the performance of virtual machines.

=head2 JSON

A popular data format. Its L<specification|http://json.org/> The
ecosystem includes many JSON related L</projects>.  Its binary
counterpart is L</BSON>.  The class L</JSON::Pretty> is part of the
core.  Thre is also support for more JSON and BSON in the L</Rakudo
Star> or the L</ecosystem>.

=head2 Junction

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

=head2 JVM

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

=head1 K

=head2 karma

A measure of appreciation on L</IRC>. Karma is set by "incrementing" a pseudo:
"jnthn++ # moar commit". It is purely notional on L</#perl6> and other Perl 6 related channels because L</dalek>
does not track karma anymore.

=head2 kebab case

A naming convention where a word boundaries in a multiple word identifier is
indicated with a dash (-) character.  For example, "is-deeply".  Popular in Lisps
and Perl 6.

See L</camel case>, L</snake case>.

=head2 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 L</symbol>. Not in Perl 6, the compiler knows by
context if an alphabetical string is a keyword, a L</function> name
used for a call or a sigiless L</parameter>. This will allow to add
new keywords to Perl 6 in the future without breaking existing
programs.

=head2 KISS

L<Keep It Simple, Stupid!|https://en.wikipedia.org/wiki/KISS_principle>, a
famous motto in computer science.

=head1 L

=head2 lambda

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

=head2 language

=head2 lazy

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

=head2 laziness

According to L</WP> "lazy evaluation, or call-by-need is an evaluation
strategy which delays the evaluation of an expression until its value is
needed (non-strict evaluation)".  In Perl 6, strings and lists can be lazy
but other values are not.  That is, their content is evaluated when needed
so they can be potentially infinite. As of January 2015, lazy strings are
not supported. They may even not make the cut for the 6.0 specification.

=head2 lexical

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

=head2 lexical pad

A data structure that holds the values of lexical variables.

=head2 lexical scope

=head2 lexical symbol

=head2 lexing

=head2 lexotic

A dynamic operation with a lexically scoped target. For example, C<return>
has a dynamic effect (it peels back the call stack), but the thing it's
returning from is a lexically defined routine.

=head2 lexpad

Short for L</lexical pad>.

=head2 LGTM

Looks good to me.

=head2 LHF

Low Hanging Fruit.

=head2 library

The compilation of a L</compilation unit> of source code written in a
non-dynamic language like C results in a library.

=head2 LIFO

L<Last In First Out|https://en.wikipedia.org/wiki/LIFO_(computing)>, a
fairly common data structure in computer science.  In Perl 6 arrays behave
as such when used as a L</stack>.  See also L</FIFO>.

=head2 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 L</metacharacters>, like L</sigil>s. For the
trained reader, they are very useful because the sigil denote an associated
L</role>

See L</TheDamian> L</answer|http://www.linuxvoice.com/interview-damian-conway/>
to the question I<Perl looks like a regular expression>.

=head2 List

=head2 list context

=head2 list to remember

A facet of a language's design that puts the onus on the user to remember
which of a group of similar constructs have certain behaviors (or requires
frequent consultation of documentation to the same effect.)  A goal of
language design is to minimize the amount of material a user must remember,
by using consistent behaviors across similar constructs, or by exposing these
behaviors through syntax.  A natural language analogy to "list to remember"
would be irregular verb conjugations.

=head2 lmddgtfy

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

=head2 LMGTFY

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

=head2 local

A local variable, in L</QAST>, is local to a L</frame>. A L</HLL> lexical variable
may end up as local in QAST if it is not captured by outer L</scope>. When the QAST is compiled and L</JIT>ed
to an executable, the value accessible thru the local, modulo some L</SSA> magic, is accessible in a processor
register. There is no relationship with the local scope in Perl 5.

=head2 LoL

B<L>ist B<o>f B<L>ist

=head2 longname

Because Perl 6 has the capability of L</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
B<longname> which consists of the name of the routine and the type signature
of its invocant arguments. See also L</shortname>, L</multi-method>, and
L</multi-sub>.

=head2 LTA

Less Than Awesome.

=head2 LTM

See L<Longest Token Matching|http://design.perl6.org/S05.html#Longest-token_matching>.

=head2 lvalue

=head1 M

=head2 machine code

Code specific to the L</instruction set> of a hardware architecture. Compare
with L</bytecode>.

=head2 magic variable

L<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
L</$_>, L</"$/">, L</$¢> and L<$!>. They are L</block> L</scope>d and are implicitly
defined at the beginning of each block.

=head2 MAIN

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

=head2 MAST

L</MoarVM> specific L</AST>. When the Perl 6 L</backend> is MoarVM, L</QAST>, the AST obtained from early stages of
L</source code> L</compilation> is converted into MAST. The MAST is then used to generate MoarVM
L</bytecode>.

=head2 Match

L<Value|/value> resulting from a L</match>.
In L</list context>, gives the positional L</capture>s list.
In L</hash context>, gives the named L</capture> hash.
In L</numeric context>, gives the matched string length.
In L</boolean context>, gives C<True> like any non-class object.

=head2 match

A match is an operation that tests a L</string> against a L</grammar> or a
L</regex>.  and returns an L</object> of L<Match> type in case of success,
otherwise a L</Nil>

Matching against a C<regex> is a special case of L</smart match>ing.

See also L</parse>.

=head2 memory

=head2 META.info

A L</JSON> file that lies in the root of a L</repository> for a project written
in Perl 6. It describes a project and list its dependencies.
Documented in L<spec.pod|https://github.com/perl6/ecosystem/blob/master/spec.pod>.

=head2 metamodel

The metamodel describes some L<OO> behaviors, like where to find a
L</method>.  This permits implementation of different OO behaviors in the
same L</VM>.  The Perl 6 implementation of the metamodel is called
L</6model>.  The metamodel should not be confused with the
L</representation>.

=head2 method

Methods are L</sub>s that are called with an L</invocant>.

=head2 MI

Multiple inheritance.

=head2 mischan

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

=head2 MMD

See L</multi-method dispatch>.

=head2 MoarVM

A virtual machine designed specifically for L</NQP> and its L</MOP>:
L</6model>.  A document about MoarVM
L<purpose|https://github.com/MoarVM/MoarVM/blob/master/docs/reveal.md>.
MoarVM has some similarities with the Hotspot VM so you may peruse its
L<glossary|http://openjdk.java.net/groups/hotspot/docs/HotSpotGlossary.html>
for entries missing from the present one.

=head2 modifier

It is an L</adverb> that affects the behavior of a L</rule> or a
L</match> The supported modifier for rules are L</:ignorecase>,
L</:ignoremark>, L</:sigspace>, L</:ratchet>, and L</:Perl5>, and their
respective abbreviations C<:i>, C<:s>, C<:r>, and C<:P5>.

:g :ov :x :ex :pos

=head2 module

=head2 MOP

Meta-Object Protocol.

=head2 MRO

Method Resolution Order.

=head2 Mu

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

=head2 multi

L</sub>s, L</method>s, or L</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
L</multi-method dispatch>.

=head2 multiple dispatch

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

=head2 multi-method

=head2 multi-sub

=head2 multi-method dispatch

=head2 mumble

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

=head2 my

=head2 MY::

A L</pseudo-scope> to access L</symbol>s  in the current L</lexical scope>
(aka $?SCOPE).

=head1 N

=head2 named parameter

=head2 namespace

=head2 native

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

=head2 Native Call

Calling a routine from an external C/C++ library, provided by the
NativeCall library (which is now bundled with L</Rakudo>).

=head2 Native value

A native value is an L</int>, L</num>, L</str>.  A native value cannot be
undefined.

=head2 name

Syntactical convention to denote an entity in a program source code. Such an
entity can be a routine, a variable...  See also : L</symbol>, L</scope>,
L</sigil>, L</role>, L</adverbial pair>.

=head2 NC

L</Native Call>

=head2 NCI

L</Native Call> Interface

=head2 need

=head2 NFA

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

=head2 NFG

Proposed L</Unicode Normalization Form> for Perl 6, in which composed
characters always get their own codepoint. If a codepoint doesn't exist for
that composed character, one is assigned dynamically.

Documentation for this can hypothetically be found in L<S15>.

=head2 Niecza

An implementation of Perl 6 targeting the .NET platform.

=head2 Nil

Means there is no value.  This is different from C<()>, the L</empty list>.

=head2 NST

No Such Thing.

=head2 nom

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

=head2 Normalization Form

=head2 NPE

Null Pointer Exception.

=head2 null-PMC access

=head2 Num

=head2 number

=head2 numeric context

=head2 NQP

Short for B<N>ot B<Q>uite B<P>erl, a subset of Perl 6 suitable for tasks
such as implementing L</Rakudo>. Targets L</Parrot>, the L</JVM> and
L</MoarVM>.

=head2 NSA

Native, Shaped Arrays.

=head1 O

=head2 obfuscation

Code deliberately unreadable often using esoteric language features.
Sometimes combined with L</golfing>.

=head2 object

=head2 object code

For non L</dynamic language>s, from a L</compilation unit>, the L</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 L</bytecode> and the linking phase is more complex and
involves the deL</serialization> of information.

=head2 On Stack Replacement

According to the hotspot
L<glossary|http://openjdk.java.net/groups/hotspot/docs/HotSpotGlossary.html>:
The process of converting an interpreted (or less optimized) L</stack frame>
into a compiled (or more optimized) stack frame.

=head2 OO

Object oriented.  See L</OOP>.

=head2 OOP

Acronym for L<Object-oriented programming|https://en.wikipedia.org/wiki/Object-oriented_programming>.

=head2 op

Ops are L</opcode>s that belong to the L</NQP> L<interpreter> or that are
dynamically charged by the interpreter of another language. The word L</extops>
is used to denote the latter ops

=head2 opcode

An opcode is an instruction in a L</bytecode> or L</AST>.  Documentation about L</MoarVM>
L<opcodes|https://github.com/MoarVM/MoarVM/blob/master/docs/bytecode.markdown>.

=head2 open source

=head2 operand

See L</operator>.

=head2 operating system

=head2 operator

An expression is made of operators and operands. More precisely it is made
of an operator and operands that can be subexpressions or L</value>s.
Operators are an alternative syntax for a L</multi-method>. With that
syntax, what would be the L</argument>s of the function are named operands
instead. Operators are classified into
L<categories|http://design.perl6.org/S02.html#Grammatical_Categories> of
categories.  A category has a precedence, an arity, and can be L</fiddly>,
L</iffy>, L</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, C<@a[0]> belongs to the postcircumfix
category, is broken into the operand C<@a> and the postcircumfix operator
C<[0]> where C<0> is the postcircumfixed subexpression.

The C<< <O(I<...>)>  >> construction gives information about an operator
that completes the information provided by its category.  Below
C<%conditional> is the category, C<< :reducecheck<ternary> >>, which
specifies calling C<.ternary> to post-process the L<parse subtree|/parse
tree> and C<< :pasttype<if> >> specifies the NQP L</opcode> generated in the
L</AST> from the parse subtree.

        <O('%conditional, :reducecheck<ternary>, :pasttype<if>')>

=head2 opt

An optimization, usually in either the context of L</spesh> or L</JIT>.

=head2 OS

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

=head2 OSR

L</On Stack Replacement>

=head2 our

=head2 OUR::

A L</pseudo-scope> to access L</symbol>s in the current package (aka $?PACKAGE).

=head2 OUTER::

A L</pseudo-scope> to access L</symbol>s in the next outer L</lexical scope>.

=head1 P

=head2 package

=head2 package manager

See L</project manager>

=head2 pad

See L</lexical pad>.

=head2 Pair

The simplest object containing a key and value pair.

=head2 pair notation

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

  foo => 1

Compare with the L</adverbial pair> notation.

=head2 Panda

A Perl 6 L</package manager> designed to make it easier to download, compile and install
L</module>s according to the transitive dependencies specified in the
C<META.info> metadata files of said modules.  Unlike other L</package
manager>s, panda supports many L</VM>s, namely the three VMs supported by
the L</Rakudo> compiler: L</MoarVM>, L</Parrot> and L</JVM>.  The official
set of modules is called the L</ecosystem> according to the L</github>
repository name that contains the module list pointing to their respective
repositories.

=head2 panda bootstrap script

=head2 parakudo

L</Rakudo> running on L</Parrot>.

=head2 parameter

In a L</signature>, defines how the corresponding L</argument> is bound when
the L</block>, L</sub> or L</method> with a signature is called.  Is often
designated as "formal parameter" in the literature about other languages.  A
parameter can be L</positional> or L</named>, either can be L</variadic> or
not.

=head2 parrakudo

See L</parakudo>.

=head2 PARENT::

A L</pseudo-scope> to access lexical L</symbol>s in the unit's L<DSL>
(usually L<CORE|/CORE::>).

=head2 Parrot

A virtual machine designed to run Perl 6 and other L</dynamic language>s.
Mostly historic.

=head2 parser

The parser is the L</compiler> part that transforms the L</source code> into
a L</parse tree>.  A parser is specified by a L</grammar>.  The code used by
the parser leverages three different engines: the L<expression|/Expression>
parser, a recursive engine, an L</NFA> based engine. L</LTM> is a feature of
the L</NFA> engine. One difference between C<|> and C<||> is that the former
involves an L</NFA>, while the latter involves the recursive engine. That's
why the former is faster than the latter.

See also L</grammar>.

=head2 parse tree

=head2 PAST

L</Parrot> L</AST>.

=head2 PAUSE

Perl Authors Upload SErvice.  The place where authors upload their
distributions to L</CPAN>.

=head2 pb

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

=head2 PBP

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

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

=head2 PEG

Parsing Expression Grammar. See L</grammar>.

=head2 Perlito

A L</compiler> project that has frontends for Perl 5 and Perl 6, as well as
multiple backends.

=head2 phaser

A piece of code (a L</blast>) that runs at a particular phase in the
program's lifecycle, for example during L<compilation|/compiler> (C<BEGIN>),
the first time a loop is entered (C<FIRST>), or after all regular code has
run (C<END>).

=head2 PIO

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

=head2 PIR

Parrot Intermediate Representation.

=head2 PMC

Parrot Magic Cookie.

=head2 pod

B<P>lain B<O>l' B<D>ocumentation, a documentation format understood by Perl
6. See L<S26|http://design.perl6.org/S26.html> for details.

=head2 pod6

Used to specify Perl 6's version of L</pod>, as opposed to Perl 5's.

=head2 pointy block

See L</lambda>.

=head2 POLA

Principle Of Least Astonishment.

=head2 POLS

Principle Of Least Surprise.

=head2 Positional

A L</role> denoting an linearly ordered composite data structure that can be
iterated.

=head2 positional parameter

=head2 postcircumfix

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

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

=head2 postfix

An operator that comes after the term it belongs to.

=head2 PPI

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

=head2 pragma

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

=head2 precedence

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

=head2 precomp

Precompiled L</compilation unit>.

=head2 prefix

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

    say ?42;    # True
    #   ^ prefix operator

=head2 predicate

L<Expression|/expression> used in a L</boolean context> by a
L</control flow> L</statement>.

=head2 precomposed codepoint

A composite codepoint (that is, formed of many L</codepoint>s), for which
L</Unicode> assigns a codepoint. Thanks to L</NFG>, a composite non precomposed
codepoint (aka a L<synthetic one|/synthetic codepoint>) has its own dynamically
assigned codepoint.


=head2 private

=head2 process

Basic execution unit in a multitasking operating system.  Processes differ
from L</thread>s in the sense that they are directly managed by the
operating system itself.

=head2 PROCESS::

A L</pseudo-scope> to access L</process>-related globals (superglobals)
L</symbol>s.

=head2 producer

=head2 program

=head2 project

A project is a L</version>ed L</repository>.
It typically contains a C<bin> folder and a C<lib> and C<t> hierarchy.
They respectively contain executable scripts, Perl 6 libraries and tests.
The list of projects is maintained in the L<ecosystem> repository.
The L</META.info> file drives the compilation and installation of the
project by the L</project management software>.

=head2 project manager

A L</program> that fetches, compiles and installs L</project>.
L</panda> is such a program.


=head2 pseudo-scope

=head2 pseudo-package

a L</package> name which meaning is contextual or predefined by the language.
For example C<MY> denotes the current L</lexical scope> and its L</symbol>s
can be listed with C<MY::.keys>.

=head2 promise

=head2 proto

A proto is a generic L</dispatcher> to L</multi>s by the same L</shortname>.

=head2 proxy

=head2 PR

Short for L</pull request>.

=head2 prove

Perl 5 script to run tests through a L</TAP> harness.
See L<prove|http://perldoc.perl.org/prove.html>.

=head2 PSA

Problem, Solution, Acceptance.

=head2 PSGI

=head2 pull request

A feature of L</github> that's used after a user has L</fork>ed a project
and made changes to it that they wish to have in the main project.

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

=head2 punctuational variable

Another name for L</magic variable>.

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

=head2 pure

A L</function>, L</method> or L</op> is pure if it has no side effect,
and the value it gives is depends only of its arguments so it is
L<referentially transparent|/referential transparent> giving the opportunity
of optimizations.

=head2 pure perl

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

=head2 p5

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

=head2 p6

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

=head2 P6W

See L</Weekly Changes>.

=head1 Q

=head2 QAST

Successor to L</PAST>.

=head2 queue

=head1 R

=head2 race

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

=head2 Rakudo

An implementation of Perl 6 originally targeting L</Parrot>, it now targets
Parrot, the L</JVM>, and L</MoarVM> through L</NQP>.

=head2 Rakudo *

Rakudo Star, a useful and at most monthly, at least quarterly distribution
of Rakudo which includes modules and L</Panda>.

=head2 R*

See L</Rakudo *>.

=head2 rakudobrew

Quick and dirty command line tool for managing L</Rakudo>
installations on Unix boxes. It can fetch the latest code from L</github>, build against
your choice of L</backend>s, and simplify version upgrades.

Definition adapted from from L</http://iinteractive.com/notebook/2015/06/02/rakudobrew.html>.

=head2 Rakudo Star daily

Daily build reports on rakudo-star to track module tests on each L</backend>.
Its L<README|https://github.com/coke/rakudo-star-daily>

=head2 rakudobug

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

=head2 range

=head2 referential transparency

=head2 regex

Short for B<Reg>ular B<Ex>pressions, an easy way of parsing text for certain
kinds of information.

=head2 regexp

An alternative abbreviation of L</regex> that usually occurs in non-Perl 6
contexts.

=head2 reification

Certain composite objects like L</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 L</memory> or would not even fit in memory like the
infinite L</range>: C<1..Inf> See also L</laziness>.

=head2 reify

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

=head2 repository

A repository contains the information pertaining to a software or its
L</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 L</github> repositories.  The official list of Perl
6 modules is the L</ecosystem> which is also stored in a repository.  When
installing a module, the L</panda> L</package manager> uses the ecosystem to
fetch the appropriate repositories for transitive dependencies.

=head2 REPR

Representation.

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

=head2 require

Require is the L</runtime> loading of a L</module> and the related L</import>s

=head2 revert

Revert is L</git> terminology. It adds a new commit to revert some changes in
a branch.  It is different from a reset that throws away changes.

=head2 roast

The Perl 6 L<specification tests|/spectest>, which live here:
L<https://github.com/perl6/roast/>.  Originally developed for L</pugs>, it
now serves all Perl 6 implementations.  Why roast? It's the B<r>epository
B<o>f B<a>ll B<s>pec B<t>ests.

=head2 role

A role can be composed with zero or more other roles, then instantiated into
a L</class>. The L</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 C<@> denotes the
C<Positional> role. So a variable C<@a> may contain a value of type C<List>
because C<List.does(Positional)>.

=head2 RC

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

2) L</Rosetta Code>

3) Request Context.

=head2 reposession

In precompilation, if an object inside a module, changes an object in another
precompiled module, it needs to indicate that it is now responsible for its
serialization: this is called "repossession" of the object by the module.

=head2 Repository

=head2 Root Object

See L<root object|http://en.wikipedia.org/wiki/Tracing_garbage_collection>.
In L</MoarVM>, routines that handles roots are declared
L<here|https://github.com/MoarVM/MoarVM/blob/master/src/gc/roots.h>.

=head2 Rosalind

L<Rosalind|http://rosalind.info/> is a platform for learning bioinformatics
and programming through problem solving.  Some of the problems are solved
through elegant Perl 6 code snippets.

=head2 Rosetta Code

L<Rosetta Code|http://rosettacode.org>, a site for comparing snippets from
different languages in how they solve various tasks.

=head2 RPA

Resizable L</PMC> Array.

=head2 RSN

Real Soon Now.

=head2 RT

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

=head2 rule

=head2 runtime

=head1 S

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

=head2 say

=head2 SC

A L</serialization context> groups together things, usually from the same
L</compilation unit>.

=head2 scalar

=head2 scope

Association of a name with an entity delimited by a L</block>.

=head2 script

A L</program> executable in its L</source code> form. Implicitly depends
on the C<setting> or explicitely L</use> L</module>s from the
L</ecosystem>

=head2 segfault

See L</segmentation fault>.

=head2 segmentation fault

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

=head2 self-clocking code

=head2 semicolon

A L</character> used to separate or terminate L</statement>s.

=head2 serialization

The serialization saves information obtained at compilation time from a
L</compilation unit> to be deserialized at load time to perform various
initialization tasks.  The saved information involves named constants,
strings, among many other things.

=head2 serialization context

=head2 SETTING::

A L</pseudo-scope> to access L</lexical symbol>s in the unit's L</DSL>
(usually CORE).

=head2 setting

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

=head2 shared library

L</operating system> level L</library> dynamically loaded by a L</process>.
When different processes load the same library, it is loaded once in memory, so
the shared adjective.

=head2 shortname

The name of a routine only; without the type signature of its invocant
arguments.  See L</longname>.

=head2 sigil

In Perl, the sigil is the first character of a variable name.  It must be
either C<$>, C<@>, C<%>, or C<&> respectively for a scalar, array, hash, or
code variable.  See also L</twigil> and L</role>.  Also sigilled variables
allow short conventions for L<variable interpolation> in a double quoted
string, or even C<postcircumfix> L<expression|/Expression>s starting with
such a variable.

=head2 signature

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

=head2 Single Static Assignment

=head2 sink context

L<Context|/context> of an expression whose value is ignored.  Often called
"void" context in other languages.

=head2 sixplanet

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

=head2 slang

Short for sublanguage. A slang is a L</grammar> derived from the Perl 6
grammar, and its associated L</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 L</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).

=head2 smart match

=head2 snake case

A naming convention where a word boundaries in a multiple word identifier is
indicated with an underscore (_) character.  For example, "is_deeply".  Popular
in Perl 5, Python, and other scripting languages.

See L</camel case>, L</kebab case>.

=head2 SMOP

Small/Simple Matter Of Programming.  The thing you do when not specifying,
documenting, discussing, lurking or idling.  See also
L<here|http://en.wikipedia.org/wiki/Small_matter_of_programming>.

=head2 slurpy

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

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

=head2 source code

Textual form of a L</program>.

=head2 spectest

Alternative name for L</roast> after the name of its target name in
L</rakudo compiler>.  A program that passes the Perl 6 L</test suite>
is a valid Perl 6 L</compiler>.
L<Link|https://github.com/perl6/roast> to the L</github>
L</repository> that contains the said test suite.

=head2 special variable

Variable with one of the L</twigil> C<?>, C<*> or C<=>; or L</magic variable>.
The said twigils respectively correspond to L</compiler constant>s, L</context variable>s
or L</pod> data.

See L<S28|http://design.perl6.org/S28.html>.

=head2 spesh

A functionality of the L</MoarVM> platform that uses run-time gathered data
to improve commonly used pieces of L</bytecode>. It is much like a L</JIT>
compiler, except that those usually output L</machine code> rather than
bytecode.

=head2 splat

=head2 SSA

See L</Single Static Assignment>.

=head2 stack frame

See L</frame>.

=head2 STable

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

=head2 stage

Can denote steps either on bootstrapping NQP, or compilation stages.

For bootstrapping stages, see L</bootstrap>.

Compilation proceeds on successive stages. Later stages are
L</backend dependent>.  When there is a dumper available, you can see
the output of one stage with the switch C<--target=I<stage_name>>.
The argument is case insensitive.  The backend independent stages are
C<parse> and C<ast>.  The L</JVM> backend specific states are C<jast>,
C<classfile>, C<jar>, C<jvm>.  For L</MoarVM>, they are C<mast>,
C<mbc>. C<moar>.

=head2 star

See L</Rakudo *>.

=head2 stash

=head2 state

=head2 statement

=head2 static frame

Data pertaining to a L</frame> gathered at compile time.

=head2 static typing

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

Compare with L</dynamic typing>, L</gradual typing>

=head2 STM

Software Transactional Memory.

=head2 Str

Name of the string type.

=head2 string

A sequence of characters.  See L</characters> for the definition of
string length according to the different abstractions underlying a
L</Unicode> string.  There is some speculation of string being
L</lazy> in some future Perl 6 version.

=head2 sub

Short for subroutine.

=head2 Subroutine

A subroutine is like a L</block>, but its L</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.

=head2 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 L<S06-routines/"Unpacking a single list argument">,
L<S06-routines/"Unpacking tree node parameters">.

Not to be confused with L<Closure parameters|/"Closure Parameter">.

=head2 supply

=head2 symbol

Fancy alternative way to denote a name. Generally used in the context of
L</module>s linking, be it in the L</OS> level, or at the Perl 6 L</VM> level
for modules generated from languages targeting these VMs.  The set of
L</import>ed or exported symbols is called the symbol table.

=head2 :sym

=head2 Synopsis

The current human-readable description of the Perl 6 language.  Still in
development.  Much more a community effort than the L</Apocalypse>s and
L<Exegeses|/Exegesis> were. The current state of the language is reflected
by L<roast>, its L</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.

=head2 syntax analysis

See L</parser>.

=head2 Syntax sugar

See L</Huffmanization>.

=head2 synthetic codepoint

A L<codepoint> for a L</grapheme> composed of many L</codepoint>s that has not a
</precomposed codepoint> defined by L</Unicode>.  L</NFG> dynamically assigns its own
codepoint for such a composition.


=head1 T

=head2 tail call

=head2 TAP

L<Test Anything Protocol|http://en.wikipedia.org/wiki/Test_Anything_Protocol>.

=head2 Task::Star

A L</bundle> that directs L</Panda> to install L</Rakudo *> L</module>s.

=head2 TCO

L<tail call> optimization.

=head2 term

=head2 test suite

The Perl 6 test suite is L</roast>

=head2 Texas operator

The ASCII variant of a non-ASCII Unicode operator or symbol.  So described
because "Everything's bigger in Texas."  For instance, C<<< >>+<< >>> is the
"Texas" form of the C<»+«> hyper-addition operator, and C<(elem)>
corresponds to the C<∈> ("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...

=head2 TheDamian

L</IRC> screen name for Damian Conway, writer of the original
L<Exegeses|/Exegesis>.

=head2 thinko

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

=head2 thread

An execution unit more lightweight than a L</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.

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

=head2 TimToady

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

=head2 TIMTOWTDI

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

=head2 tl;dr

L<Too Long; Didn't Read|http://en.wiktionary.org/wiki/TL;DR>.  Also denotes
a summary for those who are prone to claim tl;dr.

=head2 TMI

Too Much Information.

=head2 TMTOWTDI

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

=head2 token

A token is a keyword that introduces a lexing L</rule> in a grammar

=head2 topic

Expression whose value is aliased to L<$_>.

=head2 trait

=head2 TTIAR

Two Terms In A Row. A common error message often resulting from a missing
L</semicolon> between two L</statement>s or putting an operator directly
after a L</sub>.

=head2 tpyo

Typo.

=head2 tuit

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

=head2 twigil

A secondary L</sigil>. For example, C<%*ENV> has a sigil of C<%> and
a twigil of C<*>.

See L<http://design.perl6.org/S02.html#Twigils> and L<S24|http://design.perl6.org/S24.html>.

=head2 type

The type of a value C<$val> can be obtained using C<$val.WHAT> which the corresponding
type object. When a value is L<native|/native value>, the <.WHAT> macro operates on the
corresponding L<boxed|/boxing> value.

=head2 type erasure

Type annotation for a value of L</static type> is unnecessary at L</runtime>
The absence of that annotation at compared to L</compile time> is called type
erasure.

=head1 U

=head2 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
L<UAX 15|http://www.unicode.org/reports/tr15/> which covers L</Unicode
Normalization Form>s.

=head2 UCD

See L</Unicode Character Database>.

=head2 unboxing

See L</boxing>.

=head2 unspace

A way to put L</whitespace> in your code that is ignored by the parser.
Introduced with a backslash.

=head2 ufo

See L<here|https://github.com/masak/ufo/>.

=head2 UGT

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

=head2 unary

An operator is unary if its L</arity> is one. Operators belonging to the
L<categories|/category> L</prefix>, L</postfix> and L</circumfix> are unary.

=head2 Unicode

Unicode is a standard defining the encodings, representation and handling of
text in most writing systems.  This standard includes a useful L<Unicode
glossary|http://www.unicode.org/glossary/>.  For Perl 6 handling of Unicode,
see the
L<documentation|https://raw.githubusercontent.com/perl6/specs/master/S15-unicode.pod>.
See also L</NFG> for an encoding specific to Perl 6.

=head2 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
L<also|http://www.unicode.org/ucd/>.

=head2 Unicode Normalization Form

See L</UAX> L<15|http://unicode.org/reports/tr15/>.
Perl 6 defines an additional one : L</NFG>.

=head2 unit

See L</compilation unit>.

=head2 UNIT

Symbols in the outermost lexical scope of a compilation unit.

=head2 unmanaged size

The amount of memory a L</REPR> has behind it that is not under
the direct management of the L</GC>. Used for L</heap> profiling.

=head2 unslushing

See L</slushy>.

=head2 use

Use is the compilation time loading of a L</module>. That means,
contrary to L</require> that the L</import>ed L<symbols> are known at
compilation time to the rest of the compilation of the code

=head1 V

=head2 value

=head2 variable

A variable is a name for a L</container>.

=head2 variable interpolation

See L</sigil> and L<S02/Q forms>.

=head2 variadic

=head2 ver

Short way to indicate L</version>.

=head2 version

Can be obtained with C<I<perl6 -v>> with I<perl6> depending on your
L</implementation>.  This command gives something like that below for
L</Rakudo> on L</MoarVM>

  This is perl6 version 2014.08-187-gdf2245d built on MoarVM version 2014.08-55-ga5ae111

Strangely the L</NQP> related information is missing.

=head2 visibility

An L</object variable> declared with the L<!> L</twigil> can be in scope but
is not visible.

=head2 Virtual Machine

A virtual machine is the Perl compiler entity that executes the
L</bytecode>.  It can optimize the bytecode or generate L</machine code>
L<Just in Time|/JIT>.  Such as L</Parrot>, L</JVM> and L</MoarVM>.

=head2 VM

See L</Virtual Machine>.

=head2 v5

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

    use v5;

=head2 v6

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

    use v6;

=head1 W

=head2 warnocked

This lemma will never be explained.

=head2 WAT

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

=head2 Weekly Changes

Mostly weekly L<report|http://p6weekly.wordpress.com/> about changes in the
Perl 6 World.  See also: L</sixplanet>.

=head2 wfm

Works For Me.

=head2 Whatever

L<http://doc.perl6.org/type/Whatever>.

=head2 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, L</comment>s are
also considered whitespace. See also L</unspace>.

=head2 WIP

Work In Progress.

=head2 world

The world is the data about a package that is serialized when
compiling a L</compilation unit>.
the nqp and rakudo compiler have a World class handling the said data.
See L<NQP::World|https://github.com/perl6/nqp/blob/master/src/NQP/World.nqp> and
L<Rakudo::World|https://github.com/rakudo/rakudo/blob/nom/src/Perl6/World.nqp>.


=head2 WP

Wikipedia.

=head2 ww

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

=head1 X

=head2 XS

Perl 5's mechanism for bridging the gap between pure-Perl code and compiled
system libraries. Writing XS modules involves C code and some knowledge of Perl
5's inner workings, and installing them needs a compiler. The Perl 6 equivalent
is C<NativeCall>; see L<S21|S21: Calling foreign code>.

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

=head1 Y

=head2 YAPAE

Yet Another Potentially Awkward Explanation.
A term referring to the L<"curious corners"|https://perl6advent.wordpress.com/2014/12/04/composers-coercers-and-the-case-of-a-camels-curious-corner/>
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.

=head2 yoleaux

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

=head2 YOU_ARE_HERE

=head1 Z

=head2 Zavolaj

Zavolaj was a module to support L</Native Call>s into L<libraries|/library>.
It is now part of L</Rakudo>

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

=head1 *

Oh, um... L</Whatever>.

=head2 #perl6

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

=head2 .

=head2 ..

=head2 ...

=head1 :

Everybody wants the colon.

=head2 :ignorecase

=head2 :ignoremark

=head2 :ratchet

=head2 ?

=head2 (

=head3 ()

See L</empty list>.

=head2 *

=head2 @_

The Perl 5 style argument list.  Something you should stop using, and use
subroutine signatures instead.

=head2 $_

The "topic variable". Set by any construct that's a "topicalizer", like the
L</given> statement or a for loop.

=head2 $/

A L</magic variable> which L</value> is the current L</Match>, or L</nil>
if none.

=head2 $¢

L</cursor>

=head2 $!

A L</magic variable> which L</value> is the current L</Exception>

=head2 %_

=head2 ++

Way to increase L</karma> on IRC.
A L</prefix> or L</postfix> incrementation L</operator>.

=head2 &

L<Sigil|/sigil> of a L</callable> L</variable>.  Also used at the end of a
line in an L</IRC> message to indicate the user is away, doing something
else in the background.  For instance:

  sleep&

=head2 6model

The "new object model"/L</MOP> that's currently in rakudo. L</MoarVM> uses
this internally. On L</Parrot> and L</JVM>, it sits on top of the native object
model.

=head1 AUTHORS

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

=for vim:set expandtab sw=4: