/S99-glossary.pod
Unknown | 2983 lines | 1854 code | 1129 blank | 0 comment | 0 complexity | 2873b7f2c46340026c6b98d1b8607d0b MD5 | raw file
Possible License(s): AGPL-3.0
- =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: