=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 or L. It is intended as both a quick introduction to terms used on the L L on L, 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 defines the L of a class. Its Ls are left undefined. In Perl 6, abstract classes is one of the related abstractions implemented as Ls. =head2 ack An improved version of L, written in Perl (L). Also used by old folks to indicate acknowledgement. =head2 actions A class used to generate an L from the results of parsing text with a L. The method to attach a generated AST is called "make", to retrieve an AST you can call "made" or "ast". See L. =head2 advent calendar Articles about Perl 6 for every days of December before Christmas. At L. =head2 adverb See L. =head2 adverbial pair A generalized form of L. They all start with the colon, like: adverbial pair | pair notation ================|============== :foo | 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 Ls. Any is derived from L. =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, 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 and L. =head2 arity Number of Ls expected by an L. =head2 argument =head2 array =head2 AST Acronym for Lbstract Byntax Bree|http://en.wikipedia.org/wiki/Abstract_syntax_tree>. Used in many places, including L, L, and L. =head2 atomic See L. =head2 attribute Per-object storage slot. Other languages call it "Field", "Member", "Slot" or "Property". =head2 auth Way of deliberately ambiguously expressing L or L. =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 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 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. In a non-greedy match, it means moving the cursor forward. =head2 backend Denote a VM targeted by L. Can be L, L or L. =head2 Bailador Spanish for "dancer", The Bailador module (L) is a port of Perl 5's Dancer web framework (L). =head2 bare string A non-quoted alphanumeric string. In Perl 6, only allowed at the left of a L. =head2 biab Back In A Bit. Only L for a little while. =head2 binary An operator is binary or of L two if its L is L or L. =head2 blast "Bock, Blternatively Batement". Several constructs in Perl 6 expect either a single L, or a L. Thus, a blast: try { dangerous(); functions() }; # ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Block try dangerous-function(); # ^^^^^^^^^^^^^^^^^^^^ Statement Particularly cute, because Ls expect blasts. =head2 block A source code section delimited by braces and may have an explicit L. Used for L and as L. A L in a block returns from the enclosing L. A block is a L which makes it useful for L. =head2 blorst "Bock, B Batement". Different way to say L. =head2 Bool L type. =head2 boolean L of type L. Apart the class itself, can be either C or C. =head2 boolean context A L that forces an L to give a L value. The L Ls C, C and their respective higher L C and C forms force a boolean context with C and C doing a negation. The L part of a L L forces a boolean context. A class can define a C method to handle the boolean context. For L, within L, it is handled by C member of the L 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 about bootstrapping the L of L =head2 bot A program that does automatic tasks on one or more L 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, L and L are bots on the L channel. =head2 boxing Operation transforming a L into an object. The reverse operation is unboxing. The relation between boxed/native should not be confused with L/containee. =head2 branch =head2 brb Be Right Back. Only L for a little while. =head2 BS Bounded Serialization. =head2 BSON BSON is the binary counterpart to the textual L data format. Used by Mongodb and supported by the L L. =head2 Bug report The way to report problems to the implementors. For the interpreters themselves, use L. It is good practice to include the interpreter L 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 For the user packages hosted on L, you can report issues. =head2 bundle A bundle is a special L that directs L to install a list of modules. See also: L. =head2 bytecode Bytecode is to a L what L is to a CPU but, unlike machine code, is portable. From L L can generate bytecode for the L and L virtual machines. When executing a script, rakudo does not need to compile the used Ls because they should already be available as bytecode installed by L. =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 to access Ls in the L's L. =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, L. =head2 Camelia The butterfly-like logo of Perl 6 as can be observed at L. =head2 camelia The L on #perl6 channel that will evaluate code for you in various versions of Perl 5, Perl 6 and L. =head2 capture A regex can record substrings of the Led 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 Ls, regex of a L form a category that are distinguished by their L. That includes the L but also the value of the L adverb. An L consists of tokens that belong either in the category L or one of the L's categories. A regex definition for one of the term kinds : token term:sym { ... } =head2 CFG 1) Context Free Grammar. 2) see L. =head2 character A L is a sequence of characters. Like in Perl 5, there is no character type in Perl 6 so when someone says a I about a L, he means a string with one character. In L a character is called a L and may be composed of many L. But a string represented in the L 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 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 ; # ^^^^^^^ circumfix =head2 class A basic software structure in L. See the L. =head2 CLI Command Line Interface, what you see in a Terminal (window). =head2 clog To L. Etymology: There is a website C 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 as their argument: sub call-me(&callback:(Str)) { ... } Not to be mistaken for L. See also L. =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, or comments that appear after a name declaration that are included in the L documentation. =head2 compilation unit A L is a set of files or a string that is compiled at once. It involves the L of code and data. =head2 compile time =head2 compiler In a L like Perl 6, the compiler is also referred to as L. 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 to L, the first conceptual phase is called L and generates a L. 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 in a L. Then, this bytecode is executed. Depending on the type of the data manipulated by the L, bytecode can be transformed into optimised bytecode or into L. These last two operations are forms of L. =head2 compiler constant A L with a C L. See L and L. =head2 COMPILING:: A L to access lexical Ls in the L being compiled. =head2 composer A composer is a syntax for defining Ls. When values are Ls, their composer is a L of a L L. For an example, see the L. =head2 compunit See L. =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 Les or Ls. Collaboration involves synchronization primitives likes mutexes, locks, semaphores. Perl 6 provides high level abstractions like Ls, Ls, Ls, Ls, L so that the programmer is usually spared the explicit use of threads and the endless problems they involve. Compare with L. See L. =head2 concrete An L L is concrete when it is not the L itself. =head2 concrete syntax =head2 container =head2 context A context specifies the kind of value expected from an L. A context may be L, L, L, L or L. Some L Ls are used to force the context. Context is also information that can affect parsing =head2 context variable A L with a C<*> L. Used to set up contextual information that can be shadowed by calls deeper in the L. Heavily used in the Perl 6 compiler because Perl 6 is a very contextual language, so gathered information affects the parsing. See L for an example. See also L, L and L. 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, a L graph generated from L analysis so that L can be done. =head2 constant A L that has an unchangeable L. =head2 constructor The OO way to I an object. Ls are constructor Ls that are available for the most common types like Ls. =head2 CORE:: A L to access Ls of the outermost lexical L, definition of standard Perl. =head2 CPAN Comprehensive Perl Archive Network. A content delivery system for Perl distributions. =head2 credentials =head2 CUR Short for C, the type of objects that inhabit C<@?INC>. =head2 CURL Short for C, the type of C objects that refer to the local file system. =head2 CURLI Short for C. =head2 cursor =head1 D =head2 dalek An L L that reports when various projects have been updated. It used to give L 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 that introduces a L and defines its L and L. Perl 6 declarators are L, L, L, L, respectively for L , L, and L. Also the L C in the name of a package or lexical variable sets its extent to L. =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. =head2 dies_ok A C function that succeeds when its argument, a Code object, dies at run time. See L. =head2 diffy An L that produces a resulting L of a L different from its Ls. For example, all the comparison operators like C<==> and C are diffy (because they produce Cs), the range operators are diffy (because they produce ranges), but C<+> and C<~> and C 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 Ls for installing locally, or for loading from a remote location. =head2 DRY Don't Repeat Yourself =head2 DSL L. See L. =head2 Domain specific language A special-purpose language used for a particular problem domain. For instance, some web frameworks (such as L) 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 =head2 dominance See L =head2 DYNAMIC:: A L to access contextual Ls in my or any L's lexical L. =head2 dynamic =head2 dynamic language =head2 dynamic typing =head2 dynamic variable the dynamic here is unrelated to the one in L. See L. =head2 DWIM Acronym for "Bo Bhat B Bean". A programming language designer motto. =head1 E =head2 eager One of the opposites of L. =head2 ecosystem The L is a repository of Perl 6 modules installable by L. L 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. =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, in which he tried to explain the Ls to the common (wo)man. Now only kept as an historical document for reference. See also L. =head2 export See L. =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. An expression is all or part of a L. =head2 extent The extent is the interval of time a L entity lives. The extent is different from the L of a name. A L can be still alive when its name is out of scope if some reference still exists. =head2 Extop An extension to the default L L in L or L. Used to support Ls specific to a language. =head1 F =head2 FAIL =head2 FAILBACK when available in a class, called when all other attempts by the L have failed. =head2 fat comma Contrary to Perl 5, C<< => >>, the fat comma does not simply separate two values but makes a L out of them. The left value can be a L. This is the only place where Perl 6 accepts a bare string. Example: foo => bar =head2 fiddly Used of an L 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, a fairly common data structure in programming languages. In Perl 6 an array behaves as such when used as a L. See also L. =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 during L. =head2 fork The creation of another process. Also, a feature of L 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. =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 =head2 frame =head2 freenode An L server that hosts Ls related to Perl 6 projects accessible through an IRC client at C. =head2 FSVO For Some Value Of. =head2 FTFY Fixed That For You. =head2 fudge Way to temporarily mark tests in the L for a specific Perl 6 version as I (so that a failure of the test will be marked ok, and a pass will be marked as an exception), or as I if they cause a L or L exception. =head2 functional programming A programming style that mostly or exclusively relies on functions, L or not. Perl 6 supports functional programming but does not force it on you. =head1 G =head2 GC Garbage collecting. =head2 gensym A Berated Bbol. Used primarily in L 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 Ls `#:G847`, `#:G848` and `#:G850` below from L 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. =head2 gimme =head2 gist A summary, or a method on objects that is invoked by L to print out the object in a human readable format. Or a paste server with L capabilities used by denizens of L. See L for the last usage. =head2 git The distributed source revision system used by many, if not all Perl 6 projects, generally hosted on L. A good L about git. A good L. =head2 git submodule A way to use a git L from one git repository. L =head2 github Online open source repository hoster using L. The L is hosted on github. =head2 given Keyword for the Perl 6 switch L. =head2 GLOBAL:: A L for L-wide L Ls, 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. =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. =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 inheritance based environment inflexibility. In non Ls, you can't dynamically add Ls/Ls for an L/L 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 Ls that group methods or attributes. A role can be dynamically added to a class or an object. =head2 gradual typing According to wikipedia I) or at L (which is L)>. Perl 6 supports gradual typing. =head2 grammar A feature of Perl 6 that uses Les 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. A grammar is composed of methods introduced by one of the three keywords C, C>, C. There is Ling only in C and C implies Ls between subrules. Parsing is done conceptually in two phases, L and L. Lexing breaks the input string in tokens that are the input of L. In Perl 6, things are not so clear cut and both phases are defined in the L. =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. See L. =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 role like the C 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. See L. =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 Ls may differ. Also, a given language may provide many flavors of them. Perl 6 provides common L to access them. C is the L C level structure that hooks to the underlying language specific representations. The L allows one to express specific semantics proper to a given L language. L provides interoperability with languages which compilers follow C language linking conventions. =head2 HLL See L. =head2 HN Hacker news as seen on L. =head2 HN'ed Being mentioned on Hacker news (L). =head2 HOW Higher Order Workings. Also the name of the method you can call on B 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. =head2 Huffmanization L 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, Ls 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 result, I (such as a match object). All the comparison operators are iffy, as are conditional operators like C<&&>, C, and C. 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 Ls 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. =head2 int =head2 interface An interface is an L. =head2 Intermediate Representation In a compiler, Intermediate data structures that are generated from the L to generate L or L. In L : L, and L. The L generates an IR that is transformed to an L. Sometimes the information can be regenerated from the bytecode. In Rakudo the L form is inferred from the bytecode. =head2 interpreter An interpreter is the entity that executes L generated from L in a given L. It relies on the underlying L. It may load L, that is bytecode L that are specific to the said language. =head2 instruction set An instruction set is a set of instructions specific to a L or a microprocessor. Also L defines an instruction set. Its opcodes are documented in L. =head2 invocant A L has generally one invocant but may have many according to its L. As a L(s), the parameters before the C<;>. As an L, the left L of the C<.> L. In the L C<42.say>, C<42> is the invocant. When missing, like in C<.say>, the invocant is C<$_>. =head2 invokedynamic An L that makes possible the support of Ls in L. A L about invokedynamic. =head2 IR See L =head2 IRC Internet Relay Chat. Perl 6 developers and users usually hang out on the L L on L. See also L. =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 object like a L or a L. Generally, iterator Ls 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 running on the L. =head2 JAST Intermediate representation of code used in the JVM backend of Rakudo and NQP. =head2 JIT L, a technique for improving the performance of virtual machines. =head2 JSON A popular data format. Its L The ecosystem includes many JSON related L. Its binary counterpart is L. The class L is part of the core. Thre is also support for more JSON and BSON in the L or the L. =head2 Junction A compound type that is transparent to many operations. See L. =head2 JVM Java Virtual Machine. The virtual machine for the Java programming language. Now many programming languages including Perl 6 have Ls targeting the JVM. =head1 K =head2 karma A measure of appreciation on L. Karma is set by "incrementing" a pseudo: "jnthn++ # moar commit". It is purely notional on L and other Perl 6 related channels because L 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, L. =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. Not in Perl 6, the compiler knows by context if an alphabetical string is a keyword, a L name used for a call or a sigiless L. This will allow to add new keywords to Perl 6 in the future without breaking existing programs. =head2 KISS L, 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 "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 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. =head2 LGTM Looks good to me. =head2 LHF Low Hanging Fruit. =head2 library The compilation of a L of source code written in a non-dynamic language like C results in a library. =head2 LIFO L, a fairly common data structure in computer science. In Perl 6 arrays behave as such when used as a L. See also L. =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, like Ls. For the trained reader, they are very useful because the sigil denote an associated L See L L to the question I. =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 =head2 LMGTFY Let Me Google That For You. L =head2 local A local variable, in L, is local to a L. A L lexical variable may end up as local in QAST if it is not captured by outer L. When the QAST is compiled and Led to an executable, the value accessible thru the local, modulo some L magic, is accessible in a processor register. There is no relationship with the local scope in Perl 5. =head2 LoL Bist Bf Bist =head2 longname Because Perl 6 has the capability of L, 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 which consists of the name of the routine and the type signature of its invocant arguments. See also L, L, and L. =head2 LTA Less Than Awesome. =head2 LTM See L. =head2 lvalue =head1 M =head2 machine code Code specific to the L of a hardware architecture. Compare with L. =head2 magic variable L 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 Ld and are implicitly defined at the beginning of each block. =head2 MAIN When present, a LL that is the entry point of a L L. The code in Ls intended to run at compile time are executed before MAIN. Like in Perl 5, a MAIN sub is not necessary. =head2 MAST L specific L. When the Perl 6 L is MoarVM, L, the AST obtained from early stages of L L is converted into MAST. The MAST is then used to generate MoarVM L. =head2 Match L resulting from a L. In L, gives the positional Ls list. In L, gives the named L hash. In L, gives the matched string length. In L, gives C like any non-class object. =head2 match A match is an operation that tests a L against a L or a L. and returns an L of L type in case of success, otherwise a L Matching against a C is a special case of Ling. See also L. =head2 memory =head2 META.info A L file that lies in the root of a L for a project written in Perl 6. It describes a project and list its dependencies. Documented in L. =head2 metamodel The metamodel describes some L behaviors, like where to find a L. This permits implementation of different OO behaviors in the same L. The Perl 6 implementation of the metamodel is called L. The metamodel should not be confused with the L. =head2 method Methods are Ls that are called with an L. =head2 MI Multiple inheritance. =head2 mischan A case of having put a message on the wrong (IRC) channel. =head2 MMD See L. =head2 MoarVM A virtual machine designed specifically for L and its L: L. A document about MoarVM L. MoarVM has some similarities with the Hotspot VM so you may peruse its L for entries missing from the present one. =head2 modifier It is an L that affects the behavior of a L or a L The supported modifier for rules are L, L, L, L, and L, 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 Ls, Ls, or Ls 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. =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 to access Ls in the current L (aka $?SCOPE). =head1 N =head2 named parameter =head2 namespace =head2 native Something that does not pertain the Perl interpreter proper but to the L or the underlying system. See also: L =head2 Native Call Calling a routine from an external C/C++ library, provided by the NativeCall library (which is now bundled with L). =head2 Native value A native value is an L, L, L. 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, L, L, L, L. =head2 NC L =head2 NCI L Interface =head2 need =head2 NFA Nondeterministic Finite Automaton, an algorithmic technique used by the regex engine. See: L. =head2 NFG Proposed L 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. =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. =head2 NST No Such Thing. =head2 nom The name of the main branch of current L in L. 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 Bot Buite B

erl, a subset of Perl 6 suitable for tasks such as implementing L. Targets L, the L and L. =head2 NSA Native, Shaped Arrays. =head1 O =head2 obfuscation Code deliberately unreadable often using esoteric language features. Sometimes combined with L. =head2 object =head2 object code For non Ls, from a L, the L 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 and the linking phase is more complex and involves the deL of information. =head2 On Stack Replacement According to the hotspot L: The process of converting an interpreted (or less optimized) L into a compiled (or more optimized) stack frame. =head2 OO Object oriented. See L. =head2 OOP Acronym for L. =head2 op Ops are Ls that belong to the L L or that are dynamically charged by the interpreter of another language. The word L is used to denote the latter ops =head2 opcode An opcode is an instruction in a L or L. Documentation about L L. =head2 open source =head2 operand See L. =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 Ls. Operators are an alternative syntax for a L. With that syntax, what would be the Ls of the function are named operands instead. Operators are classified into L of categories. A category has a precedence, an arity, and can be L, L, L. 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<< )> >> construction gives information about an operator that completes the information provided by its category. Below C<%conditional> is the category, C<< :reducecheck >>, which specifies calling C<.ternary> to post-process the L and C<< :pasttype >> specifies the NQP L generated in the L from the parse subtree. , :pasttype')> =head2 opt An optimization, usually in either the context of L or L. =head2 OS Operating system. See L. =head2 OSR L =head2 our =head2 OUR:: A L to access Ls in the current package (aka $?PACKAGE). =head2 OUTER:: A L to access Ls in the next outer L. =head1 P =head2 package =head2 package manager See L =head2 pad See L. =head2 Pair The simplest object containing a key and value pair. =head2 pair notation Way of expressing key/value pairs, using the L, creating a L object, for instance: foo => 1 Compare with the L notation. =head2 Panda A Perl 6 L designed to make it easier to download, compile and install Ls according to the transitive dependencies specified in the C metadata files of said modules. Unlike other Ls, panda supports many Ls, namely the three VMs supported by the L compiler: L, L and L. The official set of modules is called the L according to the L repository name that contains the module list pointing to their respective repositories. =head2 panda bootstrap script =head2 parakudo L running on L. =head2 parameter In a L, defines how the corresponding L is bound when the L, L or L with a signature is called. Is often designated as "formal parameter" in the literature about other languages. A parameter can be L or L, either can be L or not. =head2 parrakudo See L. =head2 PARENT:: A L to access lexical Ls in the unit's L (usually L). =head2 Parrot A virtual machine designed to run Perl 6 and other Ls. Mostly historic. =head2 parser The parser is the L part that transforms the L into a L. A parser is specified by a L. The code used by the parser leverages three different engines: the L parser, a recursive engine, an L based engine. L is a feature of the L engine. One difference between C<|> and C<||> is that the former involves an L, while the latter involves the recursive engine. That's why the former is faster than the latter. See also L. =head2 parse tree =head2 PAST L L. =head2 PAUSE Perl Authors Upload SErvice. The place where authors upload their distributions to L. =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. =head2 Perlito A L project that has frontends for Perl 5 and Perl 6, as well as multiple backends. =head2 phaser A piece of code (a L) that runs at a particular phase in the program's lifecycle, for example during L (C), the first time a loop is entered (C), or after all regular code has run (C). =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

lain Bl' Bocumentation, a documentation format understood by Perl 6. See L for details. =head2 pod6 Used to specify Perl 6's version of L, as opposed to Perl 5's. =head2 pointy block See L. =head2 POLA Principle Of Least Astonishment. =head2 POLS Principle Of Least Surprise. =head2 Positional A L 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. =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 for details. =head2 precomp Precompiled L. =head2 prefix An operator that comes before the term it belongs to, for example say ?42; # True # ^ prefix operator =head2 predicate L used in a L by a L L. =head2 precomposed codepoint A composite codepoint (that is, formed of many Ls), for which L assigns a codepoint. Thanks to L, a composite non precomposed codepoint (aka a L) has its own dynamically assigned codepoint. =head2 private =head2 process Basic execution unit in a multitasking operating system. Processes differ from Ls in the sense that they are directly managed by the operating system itself. =head2 PROCESS:: A L to access L-related globals (superglobals) Ls. =head2 producer =head2 program =head2 project A project is a Led L. It typically contains a C folder and a C and C hierarchy. They respectively contain executable scripts, Perl 6 libraries and tests. The list of projects is maintained in the L repository. The L file drives the compilation and installation of the project by the L. =head2 project manager A L that fetches, compiles and installs L. L is such a program. =head2 pseudo-scope =head2 pseudo-package a L name which meaning is contextual or predefined by the language. For example C denotes the current L and its Ls can be listed with C. =head2 promise =head2 proto A proto is a generic L to Ls by the same L. =head2 proxy =head2 PR Short for L. =head2 prove Perl 5 script to run tests through a L harness. See L. =head2 PSA Problem, Solution, Acceptance. =head2 PSGI =head2 pull request A feature of L that's used after a user has Led 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. =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, L or L is pure if it has no side effect, and the value it gives is depends only of its arguments so it is L giving the opportunity of optimizations. =head2 pure perl Use to qualify Some source code, or L that does not depend on non Perl resources like a L 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. =head1 Q =head2 QAST Successor to L. =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, it now targets Parrot, the L, and L through L. =head2 Rakudo * Rakudo Star, a useful and at most monthly, at least quarterly distribution of Rakudo which includes modules and L. =head2 R* See L. =head2 rakudobrew Quick and dirty command line tool for managing L installations on Unix boxes. It can fetch the latest code from L, build against your choice of Ls, and simplify version upgrades. Definition adapted from from L. =head2 Rakudo Star daily Daily build reports on rakudo-star to track module tests on each L. Its L =head2 rakudobug A bug in L. Usually used in contexts such as "/me submits rakudobug". =head2 range =head2 referential transparency =head2 regex Short for Bular Bpressions, an easy way of parsing text for certain kinds of information. =head2 regexp An alternative abbreviation of L that usually occurs in non-Perl 6 contexts. =head2 reification Certain composite objects like L 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 or would not even fit in memory like the infinite L: C<1..Inf> See also L. =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 Ls. 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 repositories. The official list of Perl 6 modules is the L which is also stored in a repository. When installing a module, the L L 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 loading of a L and the related Ls =head2 revert Revert is L 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, which live here: L. Originally developed for L, it now serves all Perl 6 implementations. Why roast? It's the Bepository Bf Bll Bpec Bests. =head2 role A role can be composed with zero or more other roles, then instantiated into a L. The L 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 role. So a variable C<@a> may contain a value of type C because C. =head2 RC 1) Release Candidate, a last chance to find terrible bugs or non-portabilities before the actual release. 2) L 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. In L, routines that handles roots are declared L. =head2 Rosalind L 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, a site for comparing snippets from different languages in how they solve various tasks. =head2 RPA Resizable L Array. =head2 RSN Real Soon Now. =head2 RT Request Tracker (L). To open a ticket, email> C. =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 groups together things, usually from the same L. =head2 scalar =head2 scope Association of a name with an entity delimited by a L. =head2 script A L executable in its L form. Implicitly depends on the C or explicitely L Ls from the L =head2 segfault See L. =head2 segmentation fault Something that should never, ever happen. Complain on #perl6 if you see one. =head2 self-clocking code =head2 semicolon A L used to separate or terminate Ls. =head2 serialization The serialization saves information obtained at compilation time from a L 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 to access Ls in the unit's L (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 level L dynamically loaded by a L. 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. =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 and L. Also sigilled variables allow short conventions for L in a double quoted string, or even C Ls starting with such a variable. =head2 signature A signature is used by Ls, Ls or L to specify the L they can receive when they are called. =head2 Single Static Assignment =head2 sink context L of an expression whose value is ignored. Often called "void" context in other languages. =head2 sixplanet L is a collation of blogs related to Perl 6. If planeteria.org is down, a replacement can be found on L. =head2 slang Short for sublanguage. A slang is a L derived from the Perl 6 grammar, and its associated L. 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 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, L. =head2 SMOP Small/Simple Matter Of Programming. The thing you do when not specifying, documenting, discussing, lurking or idling. See also L. =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. =head2 spectest Alternative name for L after the name of its target name in L. A program that passes the Perl 6 L is a valid Perl 6 L. L to the L L that contains the said test suite. =head2 special variable Variable with one of the L C, C<*> or C<=>; or L. The said twigils respectively correspond to Ls, Ls or L data. See L. =head2 spesh A functionality of the L platform that uses run-time gathered data to improve commonly used pieces of L. It is much like a L compiler, except that those usually output L rather than bytecode. =head2 splat =head2 SSA See L. =head2 stack frame See L. =head2 STable Representation independent data structure associated with the type of an object. Part of the L. See L. =head2 stage Can denote steps either on bootstrapping NQP, or compilation stages. For bootstrapping stages, see L. Compilation proceeds on successive stages. Later stages are L. When there is a dumper available, you can see the output of one stage with the switch C<--target=I>. The argument is case insensitive. The backend independent stages are C and C. The L backend specific states are C, C, C, C. For L, they are C, C. C. =head2 star See L. =head2 stash =head2 state =head2 statement =head2 static frame Data pertaining to a L gathered at compile time. =head2 static typing In a language with stating typing, at L, values don't need to be annotated with their type. See L. Compare with L, L =head2 STM Software Transactional Memory. =head2 Str Name of the string type. =head2 string A sequence of characters. See L for the definition of string length according to the different abstractions underlying a L string. There is some speculation of string being L in some future Perl 6 version. =head2 sub Short for subroutine. =head2 Subroutine A subroutine is like a L, but its L 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, L. Not to be confused with L. =head2 supply =head2 symbol Fancy alternative way to denote a name. Generally used in the context of Ls linking, be it in the L level, or at the Perl 6 L level for modules generated from languages targeting these VMs. The set of Led 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 Ls and L were. The current state of the language is reflected by L, its L, 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. =head2 Syntax sugar See L. =head2 synthetic codepoint A L for a L composed of many Ls that has not a defined by L. L dynamically assigns its own codepoint for such a composition. =head1 T =head2 tail call =head2 TAP L. =head2 Task::Star A L that directs L to install L Ls. =head2 TCO L optimization. =head2 term =head2 test suite The Perl 6 test suite is L =head2 ASCII operator The ASCII variant of a non-ASCII Unicode operator or symbol. For instance, C<<< >>+<< >>> is the "ASCII" 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. ASCII 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 screen name for Damian Conway, writer of the original L. =head2 thinko A thinkographical error; i.e. a small mistake made by improperly expecting code to L or from an interrupted thought process. =head2 thread An execution unit more lightweight than a L. 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 screen name for Larry Wall, creator of Perl. The name comes from the pronunciation of L as a word. =head2 TIMTOWTDI An alternative form of L, explicitly including the "is" from the contraction "There's". =head2 tl;dr L. 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 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 between two Ls or putting an operator directly after a L. =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. For example, C<%*ENV> has a sigil of C<%> and a twigil of C<*>. See L and L. =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, the <.WHAT> macro operates on the corresponding L value. =head2 type erasure Type annotation for a value of L is unnecessary at L The absence of that annotation at compared to L 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 which covers Ls. =head2 UCD See L. =head2 unboxing See L. =head2 unspace A way to put L in your code that is ignored by the parser. Introduced with a backslash. =head2 ufo See L. =head2 UGT "Universal Greeting Time" - i.e., it's always "morning". =head2 unary An operator is unary if its L is one. Operators belonging to the L L, L and L 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. For Perl 6 handling of Unicode, see the L. See also L 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. =head2 Unicode Normalization Form See L L<15|http://unicode.org/reports/tr15/>. Perl 6 defines an additional one : L. =head2 unit See L. =head2 UNIT Symbols in the outermost lexical scope of a compilation unit. =head2 unmanaged size The amount of memory a L has behind it that is not under the direct management of the L. Used for L profiling. =head2 unslushing See L. =head2 use Use is the compilation time loading of a L. That means, contrary to L that the Led L 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. =head2 variable interpolation See L and L. =head2 variadic =head2 ver Short way to indicate L. =head2 version Can be obtained with C> with I depending on your L. This command gives something like that below for L on L This is perl6 version 2014.08-187-gdf2245d built on MoarVM version 2014.08-55-ga5ae111 Strangely the L related information is missing. =head2 visibility An L declared with the L L can be in scope but is not visible. =head2 Virtual Machine A virtual machine is the Perl compiler entity that executes the L. It can optimize the bytecode or generate L L. Such as L, L and L. =head2 VM See L. =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. Often used as the opposite of L. =head2 Weekly Changes Mostly weekly L about changes in the Perl 6 World. See also: L. =head2 wfm Works For Me. =head2 Whatever L. =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, Ls are also considered whitespace. See also L. =head2 WIP Work In Progress. =head2 world The world is the data about a package that is serialized when compiling a L. the nqp and rakudo compiler have a World class handling the said data. See L and L. =head2 WP Wikipedia. =head2 ww Short for C. 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; see L. =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 on #perl6 that is your personal assistant. See L and L. =head2 YOU_ARE_HERE =head1 Z =head2 Zavolaj Zavolaj was a module to support Ls into L. It is now part of L =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. =head2 #perl6 L L on L that hosts discussions related to Perl 6. Archived on L. =head2 . =head2 .. =head2 ... =head1 : Everybody wants the colon. =head2 :ignorecase =head2 :ignoremark =head2 :ratchet =head2 ? =head2 ( =head3 () See L. =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 statement or a for loop. =head2 $/ A L which L is the current L, or L if none. =head2 $¢ L =head2 $! A L which L is the current L =head2 %_ =head2 ++ Way to increase L on IRC. A L or L incrementation L. =head2 & L of a L L. Also used at the end of a line in an L message to indicate the user is away, doing something else in the background. For instance: sleep& =head2 6model The "new object model"/L that's currently in rakudo. L uses this internally. On L and L, it sits on top of the native object model. =head1 AUTHORS Elizabeth Mattijsen (liz@wenzperl.nl) Moritz Lenz Larry Wall =for vim:set expandtab sw=4: