/S99-glossary.pod
Unknown | 2983 lines | 1854 code | 1129 blank | 0 comment | 0 complexity | 2873b7f2c46340026c6b98d1b8607d0b MD5 | raw file
Possible License(s): AGPL-3.0
Large files files are truncated, but you can click here to view the full file
- =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 …
Large files files are truncated, but you can click here to view the full file