PageRenderTime 53ms CodeModel.GetById 17ms RepoModel.GetById 0ms app.codeStats 0ms

/S99-glossary.pod

http://github.com/perl6/specs
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

  1. =encoding utf8
  2. =head1 TITLE
  3. Synopsis 99: Glossary
  4. =head1 VERSION
  5. Created: 26 June 2013
  6. Last Modified: 26 Feb 2015
  7. Version: 8
  8. This document tries to define many of the terms used within the Perl 6
  9. community. It does not have an L</apocalypse> or L</exegesis
  10. predecessor>. It is intended as both a quick introduction to terms
  11. used on the L</#perl6> L</channel> on L</freenode>, as well as a more
  12. permanent, and deeper source of explanations in the context of Perl 6.
  13. If you, as a reader, miss a term in a glossary, just add the term with the
  14. explanation. Or if you are not sure what the missing term means, just add a
  15. header for the term. Without doubt, someone else more knowledgeable will add
  16. the explanation later for you and everybody else.
  17. =head1 A
  18. =head2 Abstract class
  19. An abstract L</class> defines the L</interface> of a class. Its L</method>s are left
  20. undefined. In Perl 6, abstract classes is one of the related abstractions implemented as
  21. L</role>s.
  22. =head2 ack
  23. An improved version of L</grep>, written in Perl (L<http://beyondgrep.com>).
  24. Also used by old folks to indicate acknowledgement.
  25. =head2 actions
  26. A class used to generate an L</AST> from the results of parsing text with a
  27. L</grammar>. The method to attach a generated AST is called "make", to retrieve
  28. an AST you can call "made" or "ast". See L<S05-regex/Action objects>.
  29. =head2 advent calendar
  30. Articles about Perl 6 for every days of December before Christmas.
  31. At L<https://perl6advent.wordpress.com/>.
  32. =head2 adverb
  33. See L<adverbial pair>.
  34. =head2 adverbial pair
  35. A generalized form of L</pair notation>. They all start with the colon, like:
  36. adverbial pair | pair notation
  37. ================|==============
  38. :foo<bar> | foo => 'bar'
  39. :foo(bar) | foo => bar
  40. :$foo | foo => $foo
  41. :foo | foo => True
  42. :!foo | foo => False
  43. =head2 AFAICS
  44. As Far As I Can See.
  45. =head2 AFAICT
  46. As Far As I Can Tell.
  47. =head2 AFAIK
  48. As Far As I Know.
  49. =head2 afk
  50. Away From Keyboard. Logged in, but there's no one looking at the screen.
  51. =head2 ALAP
  52. As Late As Possible
  53. =head2 Any
  54. The class from which most things derive, except for L</Junction>s.
  55. Any is derived from L</Mu>.
  56. =head2 any()
  57. A Junction with "or" semantics.
  58. =head2 API
  59. Application Programming Interface. Ideally, someone using your system or
  60. library should be able to do so with knowledge only of the API, but not
  61. necessarily knowing anything about the internals or implementation.
  62. =head2 Apocalypse
  63. A document originally written by L</TimToady>, in which he processed the
  64. initial barrage of RFC's that came out of the Perl community. Now only kept
  65. as an historical document for reference. See also L</Exegesis> and
  66. L</Synopsis>.
  67. =head2 arity
  68. Number of L</operand>s expected by an L</operator>.
  69. =head2 argument
  70. =head2 array
  71. =head2 AST
  72. Acronym for
  73. L<B<A>bstract B<S>yntax B<T>ree|http://en.wikipedia.org/wiki/Abstract_syntax_tree>.
  74. Used in many places, including L</actions>, L</PAST>, and L</QAST>.
  75. =head2 atomic
  76. See L</CAS>.
  77. =head2 attribute
  78. Per-object storage slot. Other languages call it "Field", "Member", "Slot" or
  79. "Property".
  80. =head2 auth
  81. Way of deliberately ambiguously expressing L</author> or L</authority>.
  82. =head2 author
  83. =head2 authority
  84. =head2 autopun
  85. "Are you ignorant or apathetic?" - "I don't know, and I don't care."
  86. =head1 B
  87. =head2 backlog
  88. That part of a discussion on an L</IRC> channel that you've missed. If it
  89. is not or no longer available in your IRC client, you can go to sites such
  90. as L<http://irc.perl6.org> to see what has been logged for you.
  91. =head2 backtrack
  92. Feature of a combinatorial algorithm which goes back one step toward the
  93. trunk after failing exploring a branch of the potential solution space. A
  94. string match is such an algorithm. Here, backtracking usually means moving
  95. back the L</cursor>. In a non-greedy match, it means moving the cursor
  96. forward.
  97. =head2 backend
  98. Denote a VM targeted by L</Rakudo>. Can be L</MoarVM>, L</JVM> or
  99. L</Parrot>.
  100. =head2 Bailador
  101. Spanish for "dancer", The Bailador module
  102. (L<https://github.com/tadzik/Bailador/>) is a port of Perl 5's Dancer web
  103. framework (L<http://perldancer.org/>).
  104. =head2 bare string
  105. A non-quoted alphanumeric string. In Perl 6, only allowed at the left of a
  106. L</fat comma>.
  107. =head2 biab
  108. Back In A Bit. Only L</afk> for a little while.
  109. =head2 binary
  110. An operator is binary or of L</arity> two if its L</category> is L</infix>
  111. or L</postcircumfix>.
  112. =head2 blast
  113. "B<Bl>ock, B<A>lternatively B<St>atement". Several constructs in Perl 6
  114. expect either a single L</statement>, or a L</block>. Thus, a blast:
  115. try { dangerous(); functions() };
  116. # ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Block
  117. try dangerous-function();
  118. # ^^^^^^^^^^^^^^^^^^^^ Statement
  119. Particularly cute, because L</phaser>s expect blasts.
  120. =head2 block
  121. A source code section delimited by braces and may have an explicit L</signature>.
  122. Used for L</control flow> and as L</scope>.
  123. A L</return> in a block returns from the enclosing L<subroutine>.
  124. A block is a L</first class entity> which makes it useful for L<functional programming>.
  125. =head2 blorst
  126. "B<Bl>ock, B<OR> B<St>atement". Different way to say L</blast>.
  127. =head2 Bool
  128. L<Boolean|/boolean> type.
  129. =head2 boolean
  130. L<Value|/value> of type L</Bool>. Apart the class itself, can be either
  131. C<True> or C<False>.
  132. =head2 boolean context
  133. A L</context> that forces an L<expression|/Expression> to give a L</boolean>
  134. value. The L</prefix> L</operator>s C<so>, C<not> and their respective
  135. higher L</precedence> C<?> and C<!> forms force a boolean context with C<!>
  136. and C<not> doing a negation. The L</predicate> part of a L</control flow>
  137. L</statement> forces a boolean context. A class can define a C<Bool> method
  138. to handle the boolean context. For L<natives|/"Native value">, within
  139. L</MoarVM>, it is handled by C</MVMBoolificationSpec> member of the
  140. L</STable> structure.
  141. =head2 bootstrap
  142. Starting up a system that uses itself to define, build or compile itself, is
  143. a practical exercise on solving the chicken and egg problem. This phase is
  144. called bootstrap.
  145. L<Documentation|https://github.com/MoarVM/MoarVM/blob/master/docs/bootstrap.markdown>
  146. about bootstrapping the L</6model> of L<MoarVM>
  147. =head2 bot
  148. A program that does automatic tasks on one or more L</IRC> channel by acting like a
  149. regular user (as far as the server is concerned) and performing some tasks that
  150. may involve answering to users requests. L</camelia>, L</dalek> and L</yoleaux>
  151. are bots on the L</#perl6> channel.
  152. =head2 boxing
  153. Operation transforming a L<native value|/"Native value"> into an object.
  154. The reverse operation is unboxing. The relation between boxed/native should
  155. not be confused with L</container>/containee.
  156. =head2 branch
  157. =head2 brb
  158. Be Right Back. Only L</afk> for a little while.
  159. =head2 BS
  160. Bounded Serialization.
  161. =head2 BSON
  162. BSON is the binary counterpart to the textual L</JSON> data format.
  163. Used by Mongodb and supported by the
  164. L<MARTIMM/BSON|https://github.com/MARTIMM/BSON/> L</project>.
  165. =head2 Bug report
  166. The way to report problems to the implementors. For the interpreters
  167. themselves, use L</RT>. It is good practice to include the interpreter
  168. L</version> in a bug report. A short piece of example code that
  169. demonstrates the bug without requiring any further set-up is usually very
  170. well received, too - see also L</golfing> For the user packages hosted on
  171. L</github>, you can report issues.
  172. =head2 bundle
  173. A bundle is a special L</module> that directs L</Panda> to install a list of modules.
  174. See also: L</Task::Star>.
  175. =head2 bytecode
  176. Bytecode is to a L</Virtual Machine> what L</machine code> is to a CPU
  177. but, unlike machine code, is portable. From L</source code> L</Rakudo>
  178. can generate bytecode for the L</JVM> and L</MoarVM> virtual machines.
  179. When executing a script, rakudo does not need to compile the used
  180. L</module>s because they should already be available as bytecode
  181. installed by L<Panda>.
  182. =head1 C
  183. =head2 callable
  184. =head2 caller
  185. The piece of code (or its lexical environment) that called a given piece of
  186. code. Generally only known at run time.
  187. =head2 CALLER::
  188. A L</pseudo-scope> to access L</symbol>s in the L</caller>'s L</scope>.
  189. =head2 camel case
  190. A naming convention where a word boundaries in a multiple word identifier is
  191. indicated with medial capitalization. For example, "isDeeply". Popular in
  192. Java, C++, C#, and Visual Basic.
  193. See L</kebab case>, L</snake case>.
  194. =head2 Camelia
  195. The butterfly-like logo of Perl 6 as can be observed at L<http://perl6.org>.
  196. =head2 camelia
  197. The L</bot> on #perl6 channel that will evaluate code for you in various versions of
  198. Perl 5, Perl 6 and L</NQP>.
  199. =head2 capture
  200. A regex can record substrings of the L</match>ed string that are matched
  201. capturing parts of the regex. That part (and the matched text) is a capture.
  202. For example
  203. if '..42' ~~ / \.+ (\d+) / {
  204. # ^^^^^ capture
  205. say $0;
  206. # ^^ capture variable
  207. }
  208. C<(I<...>)> is the capture syntax while its non-capturing counterpart is the
  209. grouping syntax : C<[I<...>]>.
  210. =head2 CAS
  211. An atomic Compare And Swap. Primitive for lock-free multi-threaded read/write
  212. access.
  213. =head2 category
  214. In L</grammar>s, regex of a L</multi> form a category that are distinguished
  215. by their L</longname>. That includes the L<signature> but also the value of
  216. the L</:sym> adverb. An L<expression|/Expression> consists of tokens that
  217. belong either in the category L</term> or one of the L</operator>'s
  218. categories.
  219. A regex definition for one of the term kinds :
  220. token term:sym<name> { ... }
  221. =head2 CFG
  222. 1) Context Free Grammar.
  223. 2) see L</Control Flow Graph>.
  224. =head2 character
  225. A L</string> is a sequence of characters. Like in Perl 5, there is no
  226. character type in Perl 6 so when someone says a I<character> about a
  227. L</value>, he means a string with one character. In L</Unicode> a
  228. character is called a L</grapheme> and may be composed of many L</codepoints>.
  229. But a string represented in the L</NFG> normalization form proper to
  230. Perl 6 has a codepoint per character. That leads to O(1) performance
  231. for many string operations. Depending on the level of abstraction, the
  232. length of a given string differs. The abstractions are bytes, codepoints and
  233. graphemes and the relevant methods are respectively L<.bytes>, L<.codes>,
  234. L<.chars>.
  235. =head2 channel
  236. Short for L</IRC> channel.
  237. Or a concurrent queue.
  238. =head2 christmas
  239. Release date for a Perl 6 implementation. It was a recurring joke because
  240. the year was not specified. But at FOSDEM 2015, TimToady announced that the
  241. target date will be Christmas 2015.
  242. =head2 circularity saw
  243. A pun on "circular saw". When bootstrapping a language in terms of itself,
  244. we must rely on circular definitions in various places. Obviously if we
  245. were really to use those circular definitions to implement our language,
  246. we'll just get stuck in an infinite regress. So instead we grab our trusty
  247. "circularity saw" to cut those circular definitions in a spot deep down,
  248. hopefully in a way that the resulting splice will be very difficult for the
  249. end-user to notice in day-to-day use.
  250. =head2 circumfix
  251. If a syntactic construct, for example a pair of parentheses, surrounds another
  252. piece of syntax, the surrounding first part is called a circumfix.
  253. say (2 + 3);
  254. # ^^^^^^^ circumfix
  255. say <a b c>;
  256. # ^^^^^^^ circumfix
  257. =head2 class
  258. A basic software structure in L</OOP>.
  259. See the L<Wikipedia entry|http://en.wikipedia.org/wiki/Class_%28computer_programming%29>.
  260. =head2 CLI
  261. Command Line Interface, what you see in a Terminal (window).
  262. =head2 clog
  263. To L</backlog>.
  264. Etymology: There is a website C<irclog.perlgeek.de> providing either IRC
  265. logs or IR clogs, depending on how you interpret the domain name.
  266. =head2 Closure Parameter
  267. A routine parameter that is a callable with particular constraints on its
  268. own parameters. For example, you may only want to accept callables that
  269. take a C<Str> as their argument:
  270. sub call-me(&callback:(Str)) { ... }
  271. Not to be mistaken for L<Subsignatures|/Subsignature>.
  272. See also L<S06-routines/Closure parameters>.
  273. =head2 CLR
  274. Common Language Runtime, as used by Niecza/mono/.NET.
  275. =head2 codepoint
  276. =head2 combining mark
  277. =head2 comment
  278. Parts of a program intended for user consumption that are not used to
  279. generate code. Beside the C<#> that starts a comment ending with the
  280. current line, Perl 6 supports many syntactic forms for different kinds of
  281. comments. Like inline comments that can be used as L</whitespace>, or
  282. comments that appear after a name declaration that are included in the
  283. L</pod> documentation.
  284. =head2 compilation unit
  285. A L</compilation unit> is a set of files or a string that is compiled at
  286. once. It involves the L</serialization> of code and data.
  287. =head2 compile time
  288. =head2 compiler
  289. In a L</dynamic language> like Perl 6, the compiler is also referred to as
  290. L</interpreter>. In simpler dynamic languages like Perl 5, the interpreter
  291. does not go through conceptual phases similar to the one for a compiler of
  292. non-dynamic language, the term compiler is rarely used.
  293. When transforming L</concrete syntax> to L</bytecode>, the first conceptual
  294. phase is called L<parsing|/parse> and generates a L</parse tree>. Next the
  295. parse tree is transformed into an abstract syntax tree which is a form that
  296. can be optimised. Next the abstract tree is transformed to L</bytecode> in a
  297. L</compilation unit>. Then, this bytecode is executed. Depending on the
  298. type of the data manipulated by the L</program>, bytecode can be transformed
  299. into optimised bytecode or into L</machine code>. These last two operations
  300. are forms of L</JIT>.
  301. =head2 compiler constant
  302. A L</variable> with a C<?> L</twigil>.
  303. See L<http://design.perl6.org/S02.html#Twigils> and L<S24|http://design.perl6.org/S24.html>.
  304. =head2 COMPILING::
  305. A L</pseudo-scope> to access lexical L</symbol>s in the L</scope> being
  306. compiled.
  307. =head2 composer
  308. A composer is a syntax for defining L</value>s. When values are L</object>s,
  309. their composer is a L</Huffmanization> of a L</constructor>
  310. L<expression|/Expression>. For an example, see the L</fat comma>.
  311. =head2 compunit
  312. See L</compilation unit>.
  313. =head2 concurrency
  314. Property of simultaneous computations sharing resources. It necessitates
  315. some form of collaboration to guaranty the consistency of the said
  316. resources. Computations are materialized by L</process>es or
  317. L</thread>s. Collaboration involves synchronization primitives
  318. likes mutexes, locks, semaphores. Perl 6 provides high level
  319. abstractions like L</feed>s, L</junction>s, L</hyperoperator>s,
  320. L</promise>s, L</channels> so that the programmer is usually spared
  321. the explicit use of threads and the endless problems they involve.
  322. Compare with L</parallelism>.
  323. See L<S17-concurrency>.
  324. =head2 concrete
  325. An L</object> L</value> is concrete when it is not the L</class> itself.
  326. =head2 concrete syntax
  327. =head2 container
  328. =head2 context
  329. A context specifies the kind of value expected from an L<expression|/Expression>.
  330. A context may be L</boolean context>, L</numeric context>, L</item context>,
  331. L</list context> or L</hash context>.
  332. Some L</prefix> L</operator>s are used to force the context.
  333. Context is also information that can affect parsing
  334. =head2 context variable
  335. A L</variable> with a C<*> L</twigil>. Used to set up contextual
  336. information that can be shadowed by calls deeper in the L</call
  337. stack>. Heavily used in the Perl 6 compiler because Perl 6 is a very
  338. contextual language, so gathered information affects the parsing. See
  339. L</keyword> for an example.
  340. See also L</lexotic>, L<http://design.perl6.org/S02.html#Twigils> and
  341. L<S24|http://design.perl6.org/S24.html>. Also called dynamic
  342. variable.
  343. =head2 control flow
  344. Without control flow statements, a program's execution would be purely
  345. sequential. A control flow statement generally uses a predicate and
  346. branches to one of its substatements according to the predicate value.
  347. =head2 Control Flow Graph
  348. In L</spesh>, a L</dominance> graph generated from L</bytecode> analysis so
  349. that L</Single Static Assignment> can be done.
  350. =head2 constant
  351. A L</variable> that has an unchangeable L</value>.
  352. =head2 constructor
  353. The OO way to I<construct> an object. L<Composer>s are constructor
  354. L</Huffmanization>s that are available for the most common types like
  355. L</pair>s.
  356. =head2 CORE::
  357. A L</pseudo-scope> to access L</symbol>s of the outermost lexical L</scope>,
  358. definition of standard Perl.
  359. =head2 CPAN
  360. Comprehensive Perl Archive Network. A content delivery system for Perl
  361. distributions.
  362. =head2 credentials
  363. =head2 CUR
  364. Short for C<CompUnitRepo>, the type of objects that inhabit C<@?INC>.
  365. =head2 CURL
  366. Short for C<CompUnitRepo::Local>, the type of C<CompUnitRepo> objects that
  367. refer to the local file system.
  368. =head2 CURLI
  369. Short for C<CompUnitRepo::Local::Installation>.
  370. =head2 cursor
  371. =head1 D
  372. =head2 dalek
  373. An L</IRC> L</bot> that reports when various projects have been updated. It
  374. used to give L</karma> to those who pushed the changes to the project.
  375. =head2 DarkPAN
  376. Perl code in production use at companies that has never been uploaded to
  377. CPAN. As in "how will this change affect the DarkPAN", which can't be
  378. answered because you generally don't have access to that code.
  379. =head2 dead code
  380. Code that is never called. For example
  381. sub f() {
  382. say 42;
  383. return;
  384. # everything below this is dead code,
  385. # because the return; above prevents it from running
  386. say 23;
  387. }
  388. =head2 debugger
  389. A piece of software that helps you to track down errors in your software.
  390. It typically allows things like stepping through code, setting breakpoints
  391. and inspecting variables.
  392. =head2 declarator
  393. a L</keyword> that introduces a L</symbol> and defines its L</scope> and
  394. L</extent>. Perl 6 declarators are L</has>, L</my>, L</state>, L</our>,
  395. respectively for L<object variable|/object> , L<lexical variable|/lexical>,
  396. <stateful variable|/stateful> and L<package variable|/package variable>. Also
  397. the L</twigil> C</*> in the name of a package or lexical variable sets its
  398. extent to L</dynamic>.
  399. =head2 destructuring
  400. =head2 dev
  401. Either a developer (person), or a development version of a program, or a
  402. branch for development in a repository.
  403. =head2 DFS
  404. Depth First Search. See L<also|http://xkcd.com/761/>.
  405. =head2 dies_ok
  406. A C<Test> function that succeeds when its argument, a Code object, dies at
  407. run time. See L<S24|http://design.perl6.org/S24.html>.
  408. =head2 diffy
  409. An L</operator> that produces a resulting L</value> of a L</type> different
  410. from its L</argument>s. For example, all the comparison operators like C<==>
  411. and C<lt> are diffy (because they produce C<Bool>s), the range operators are
  412. diffy (because they produce ranges), but C<+> and C<~> and C<x> are not
  413. diffy because they (sorta, kinda) emit what they accept.
  414. The reason we care about operators being diffy or not is that you can
  415. basically only reduce on non-diffy stuff. So C<[+]> makes sense, but C<[..]>
  416. doesn't. (C<[==]> actually does makes sense even though it's diffy, but
  417. that's because it's also chaining.) You also can't make assignment
  418. metaoperators from diffy operators. So C<+=> makes sense, but C<..=>
  419. doesn't.
  420. =head2 DIHWIDT
  421. "Doctor, It Hurts When I Do This." Well, stop doing it then.
  422. =head2 dispatcher
  423. The piece of code in the runtime that determines which (multi) method or
  424. subroutine to invoke.
  425. =head2 distribution
  426. A collection of 1 or more L</compunit>s for installing locally, or for
  427. loading from a remote location.
  428. =head2 DRY
  429. Don't Repeat Yourself
  430. =head2 DSL
  431. L</Domain specific language>. See L</slang>.
  432. =head2 Domain specific language
  433. A special-purpose language used for a particular problem domain. For
  434. instance, some web frameworks (such as L<Dancer|http://perldancer.org/>) use
  435. a DSL so that programmers can write code in terms of routes and actions
  436. rather than lower level details of parsing HTTP requests and generating HTTP
  437. responses. See also
  438. L<https://en.wikipedia.org/wiki/Domain-specific_language>
  439. =head2 dominance
  440. See L</Control Flow Graph>
  441. =head2 DYNAMIC::
  442. A L</pseudo-scope> to access contextual L</symbol>s in my or any
  443. L</caller>'s lexical L</scope>.
  444. =head2 dynamic
  445. =head2 dynamic language
  446. =head2 dynamic typing
  447. =head2 dynamic variable
  448. the dynamic here is unrelated to the one in L</dynamic typing>.
  449. See L</context variable>.
  450. =head2 DWIM
  451. Acronym for "B<D>o B<W>hat B<I> B<M>ean". A programming language designer
  452. motto.
  453. =head1 E
  454. =head2 eager
  455. One of the opposites of L</lazy>.
  456. =head2 ecosystem
  457. The L<ecosystem|https://github.com/perl6/ecosystem> is a repository of Perl
  458. 6 modules installable by L</Panda>. L</Rakudo *> releases include a tested
  459. subset of the ecosystem.
  460. =head2 edsel
  461. Something that intends to please everyone by catering for everybody's taste,
  462. yet in the end pleasing nobody, because nobody is catered for enough.
  463. =head2 empty list
  464. A list which contains no value. Denoted C<()>.
  465. =head2 EPIC FAIL
  466. An internet expression describing the very dramatic, spectacular or just funny failure of an endeavor.
  467. See the L<relevant Wikipedia entry|https://en.wikipedia.org/wiki/Failure#Internet_memes>.
  468. =head2 EVAL
  469. A Perl 6 command that takes a string as an argument and executes its content
  470. as Perl 6 code.
  471. =head2 exception
  472. =head2 Exegesis
  473. A document originally written by L</TheDamian>, in which he tried to explain
  474. the L</Apocalypse>s to the common (wo)man. Now only kept as an historical
  475. document for reference. See also L</Synopsis>.
  476. =head2 export
  477. See L</import>.
  478. =head2 EXPORT
  479. =head2 Expression
  480. An expression is a part of a statement that is constituted of operators and
  481. their operands and gives a value. The semantic of an expression may depend
  482. on its L</context>. An expression is all or part of a L</statement>.
  483. =head2 extent
  484. The extent is the interval of time a L</first class> entity lives. The
  485. extent is different from the L</scope> of a name.
  486. A L</lexical variable> can be still alive when its name is out of scope if
  487. some reference still exists.
  488. =head2 Extop
  489. An extension to the default L</bytecode> L</instruction set> in L</Parrot>
  490. or L</MoarVM>. Used to support L</opcode>s specific to a language.
  491. =head1 F
  492. =head2 FAIL
  493. =head2 FAILBACK
  494. when available in a class, called when all other attempts by the
  495. L</dispatcher> have failed.
  496. =head2 fat comma
  497. Contrary to Perl 5, C<< => >>, the fat comma does not simply separate two
  498. values but makes a L</Pair> out of them. The left value can be a L</bare
  499. string>. This is the only place where Perl 6 accepts a bare string. Example:
  500. foo => bar
  501. =head2 fiddly
  502. Used of an L</operator> that doesn't participate in forming metaoperators at
  503. all. (Because that would be "too fiddly" to get to work, presumably.) C<??
  504. !!> is such an operator. The method call operator is another. (And hence
  505. C<.=> is actually a special case, not a "real" metaoperator.) List
  506. assignment is also fiddly. (But item assignment is not.)
  507. No meta in fiddly things. So you can't reduce, negate, reverse, sequence,
  508. cross, zip, hyperify or assignify fiddly operators.
  509. =head2 FIFO
  510. L<First In First Out|https://en.wikipedia.org/wiki/FIFO>, a fairly common
  511. data structure in programming languages. In Perl 6 an array behaves as such
  512. when used as a L</queue>. See also L</LIFO>.
  513. =head2 flap
  514. Sometimes a test will fail under some conditions, but not others; when this
  515. test passes some test runs and fails others, it's called flapping.
  516. =head2 first class entity
  517. An entity that is accessible as a L</value> during L</runtime>.
  518. =head2 fork
  519. The creation of another process.
  520. Also, a feature of L</github> that copies a repository from one user to
  521. another, to allow users to make changes to a repository without needing
  522. permissions on the original project. After a user makes changes they will
  523. likely submit a L</pull request>.
  524. =head2 FOSS
  525. Free and Open-Source Software.
  526. =head2 fossil
  527. Something in a generally current document that is no longer true but which
  528. has not yet been fixed by correcting or removing it.
  529. =head2 FP
  530. Short for L</functional programming>
  531. =head2 frame
  532. =head2 freenode
  533. An L</IRC> server that hosts L</channel>s related to Perl 6 projects accessible
  534. through an IRC client at C<irc.freenode.org>.
  535. =head2 FSVO
  536. For Some Value Of.
  537. =head2 FTFY
  538. Fixed That For You.
  539. =head2 fudge
  540. Way to temporarily mark tests in the L</spectest> for a specific Perl 6
  541. version as I<todo> (so that a failure of the test will be marked ok, and a
  542. pass will be marked as an exception), or as I<skip> if they cause a
  543. L</compile time> or L</runtime> exception.
  544. =head2 functional programming
  545. A programming style that mostly or exclusively relies on functions, L</pure>
  546. or not. Perl 6 supports functional programming but does not force it on
  547. you.
  548. =head1 G
  549. =head2 GC
  550. Garbage collecting.
  551. =head2 gensym
  552. A B<gen>erated B<sym>bol. Used primarily in L</macro> parlance, a gensym acts as
  553. a "handle" on something anonymous, allowing a macro author to refer to
  554. synthetically created bits of a program after creating them. Gensyms
  555. generally look ugly, partly so as not to collide with anything else. The
  556. L</symbol>s `#:G847`, `#:G848` and `#:G850` below from
  557. L<http://lists.warhead.org.uk/pipermail/iwe/2005-July/000130.html> are
  558. gensyms:
  559. (LET* ((#:G847 X) (#:G848 FOO))
  560. (MULTIPLE-VALUE-BIND (#:G850) 1 (COMMON-LISP::%PUT #:G847
  561. #:G848 #:G850)))
  562. Current consensus is that we won't need gensyms for Perl 6 macros, because
  563. we'll have Qtree nodes which, being objects, come pre-equipped with a
  564. "handle": their object identity.
  565. =head2 GIL
  566. L<Global Interpreter Lock|https://en.wikipedia.org/wiki/Global_Interpreter_Lock>.
  567. =head2 gimme
  568. =head2 gist
  569. A summary, or a method on objects that is invoked by L</say> to print out
  570. the object in a human readable format.
  571. Or a paste server with L</git> capabilities used by denizens of
  572. L</IRC>. See L<https://gist.github.com> for the last usage.
  573. =head2 git
  574. The distributed source revision system used by many, if not all Perl 6
  575. projects, generally hosted on L</github>. A good
  576. L<glossary|https://www.kernel.org/pub/software/scm/git/docs/gitglossary.html>
  577. about git. A good L<reference|http://git-scm.com/book>.
  578. =head2 git submodule
  579. A way to use a git L<repositories|/repository> from one git repository.
  580. L<More information|http://git-scm.com/book/en/Git-Tools-Submodules>
  581. =head2 github
  582. Online open source repository hoster using L</git>. The L</ecosystem> is
  583. hosted on github.
  584. =head2 given
  585. Keyword for the Perl 6 switch L</statement>.
  586. =head2 GLOBAL::
  587. A L</pseudo-scope> for L</interpreter>-wide L</package> L</symbol>s, really
  588. UNIT::GLOBAL.
  589. =head2 GLR
  590. The Great List Refactor: a refactoring of the reification of lazy lists, so
  591. that lazy evaluation is only done when it is really needed. Expected to
  592. provide a performance benefit of several factors in certain, loop-like
  593. situations.
  594. =head2 GLRR
  595. Further Refinement of the L</GLR>.
  596. =head2 golf
  597. Shortest possible way (least amount of typed characters) to get a program to
  598. do what you want, or to describe a problem or bug.
  599. In the case of bug hunting, the aim is only partly "fewest characters" and
  600. partly "fewest concepts". The aim being to show exactly what concepts are
  601. necessary to trigger the surprising behavior.
  602. =head2 golfing
  603. The process of creating the shortest possible program to prove what you
  604. want. Sometimes also a form of L</obfuscation>.
  605. =head2 good *
  606. Good morning/afternoon/evening. Since the contributors are in many
  607. different timezones, one contributor's morning is another contributor's
  608. evening.
  609. =head2 gorilla/banana problem
  610. "You wanted a banana but what you got was a gorilla holding the banana and
  611. the entire jungle." says Joe Armstrong, Erlang creator, complaining of
  612. traditional L</OO> inheritance based environment inflexibility. In non
  613. L</dynamic language>s, you can't dynamically add L</attribute>s/L</method>s
  614. for an L</object>/L</class> so you end up shoving everything you may ever
  615. need in a deep class hierarchy. In Perl 6, the gorilla/banana problem is
  616. solved with L</role>s that group methods or attributes. A role can be
  617. dynamically added to a class or an object.
  618. =head2 gradual typing
  619. According to wikipedia I<Gradual typing is a type system in which
  620. variables may be typed either at compile-time (which is L</static typing>)
  621. or at L</runtime> (which is L</dynamic typing>)>.
  622. Perl 6 supports gradual typing.
  623. =head2 grammar
  624. A feature of Perl 6 that uses L</regex>es to implement a grammar for parsing
  625. text. Perl 6 implementations use grammars themselves to parse the language.
  626. The results of parsing with a grammar can be further passed on to
  627. L</actions>. A grammar is composed of methods introduced by one of the
  628. three keywords C<rule>, C<L</token>>, C<regex>. There is L</backtrack>ing
  629. only in C<regex> and C<rule> implies L</whitespace>s between subrules.
  630. Parsing is done conceptually in two phases, L<lexing> and L<syntax
  631. analysis>. Lexing breaks the input string in tokens that are the
  632. input of L<syntax analysis|/Syntax analysis>. In Perl 6, things are
  633. not so clear cut and both phases are defined in the L</grammar>.
  634. =head2 grapheme
  635. =head2 green threads
  636. Threads that are scheduled by the virtual machine, not by the operating
  637. system.
  638. =head2 grep
  639. Command line utility to search text for lines matching a L</regex>. See
  640. L<http://en.wikipedia.org/wiki/Grep>.
  641. =head1 H
  642. =head2 hash
  643. A data type, conveniently available in variables starting with the percent
  644. sign C<%> and provided by types conformant to the C<Associative> role like
  645. the C<Hash> type. Often called associative table in other languages.
  646. =head2 hash context
  647. =head2 heap
  648. Dynamically allocated memory pool used for memory management. Unused parts are reclaimed
  649. by the L</GC>. See L<Memory management|https://en.wikipedia.org/wiki/Memory_management#DYNAMIC>.
  650. =head2 High Level Language
  651. A high level language provides abstractions that decouples it from specific
  652. operating systems and processors. Perl 6 is such a language and provides
  653. some interoperability with other HLLs when they are compiled with the rakudo
  654. toolkit. Some of these abstractions like arrays, associative tables,
  655. integers, floats, strings and objects are common to many languages but
  656. specific semantic and underlying type L</representation>s may differ. Also,
  657. a given language may provide many flavors of them. Perl 6 provides common
  658. L</concrete syntax> to access them. C<MVMHLLConfig> is the L</MoarVM> C
  659. level structure that hooks to the underlying language specific
  660. representations. The L</metamodel> allows one to express specific semantics
  661. proper to a given L</OO> language. L</Rakudo> provides interoperability
  662. with languages which compilers follow C language linking conventions.
  663. =head2 HLL
  664. See L</High Level Language>.
  665. =head2 HN
  666. Hacker news as seen on L<https://news.ycombinator.com>.
  667. =head2 HN'ed
  668. Being mentioned on Hacker news (L<https://news.ycombinator.com>).
  669. =head2 HOW
  670. Higher Order Workings. Also the name of the method you can call on
  671. B<any> object to find out the meta-class of that object (of which the
  672. type object of an object is the instantiation).
  673. =head2 HPMoR
  674. Harry Potter and the Methods of Rationality. An inexplicably good Harry
  675. Potter fanfic with far more significance than the word "fanfic" might lead
  676. you to believe. See L<http://hpmor.com>.
  677. =head2 Huffmanization
  678. L<Huffman coding|http://en.wikipedia.org/wiki/Huffman_coding> is a
  679. compression algorithm that encodes common symbols with a short code. By
  680. analogy, we call huffmanization alternative and shorter syntax for common
  681. syntax constructs. The cost of huffmanization is the cost of learning
  682. additional syntax. In Perl 6, L</composer>s are a form of huffmanization.
  683. =head2 hyper
  684. Process data asynchronously when possible, but return the result data in the
  685. order it would have been if the source data had been processed in a single
  686. thread/process.
  687. =head2 hypothetical variable
  688. =head2 hysterical raisins
  689. Pun on historical reasons.
  690. =head1 I
  691. =head2 IC
  692. I see.
  693. =head2 iffy
  694. Used of an operator that either returns a C<Bool> result, I<or something
  695. like it> (such as a match object). All the comparison operators are iffy, as
  696. are conditional operators like C<&&>, C<?^>, and C<or>. C<%%> is iffy, but
  697. C<%> isn't. The junctive operators are iffy.
  698. The reason that we care about iffy operators is that you can only append the
  699. C<!> metaoperator to an operator that's iffy.
  700. =head2 IIRC
  701. If I Remember Correctly.
  702. =head2 IIUC
  703. If I Understand Correctly.
  704. =head2 implementation
  705. =head2 import
  706. L<Module|/module>s interact with each other through named entities called
  707. symbols. The operation that makes symbols from a module available to
  708. another module is called import while the operation of using such a name is
  709. called import.
  710. =head2 infix
  711. An operator that can appear between two terms, like the C<+> in C<40 + 2>.
  712. =head2 inline
  713. =head2 install
  714. =head2 installer
  715. =head2 Int
  716. A built-in arbitrary-sized integer type. See L<http://doc.perl6.org/type/Int>.
  717. =head2 int
  718. =head2 interface
  719. An interface is an L</abstract class>.
  720. =head2 Intermediate Representation
  721. In a compiler, Intermediate data structures that are generated from the
  722. L</source code> to generate L</object code> or L</bytecode>. In L</Rakudo>
  723. : L</parse tree>, and L<Abstract Syntax Tree|/AST>. The L</parser>
  724. generates an IR that is transformed to an L</AST>. Sometimes the
  725. information can be regenerated from the bytecode. In Rakudo the L</Single
  726. Static Assignment> form is inferred from the bytecode.
  727. =head2 interpreter
  728. An interpreter is the entity that executes L</bytecode> generated from
  729. L</source code> in a given L</language>. It relies on the underlying
  730. L</VM>. It may load L<extops>, that is bytecode L</ops> that are
  731. specific to the said language.
  732. =head2 instruction set
  733. An instruction set is a set of instructions specific to a L</bytecode>
  734. or a microprocessor. Also L</NQP> defines an instruction set. Its
  735. opcodes are documented in
  736. L<ops.markdown|https://github.com/perl6/nqp/blob/master/docs/ops.markdown>.
  737. =head2 invocant
  738. A L</method> has generally one invocant but may have many according to its
  739. L</signature>. As a L<parameter>(s), the parameters before the C<;>. As an
  740. L<argument>, the left L</operand> of the C<.> L</operator>. In the
  741. L<expression|/Expression> C<42.say>, C<42> is the invocant. When missing,
  742. like in C<.say>, the invocant is C<$_>.
  743. =head2 invokedynamic
  744. An L</opcode> that makes possible the support of L</dynamic language>s in
  745. L</JVM>. A L<presentation|http://www.infoq.com/presentations/invokedynamic>
  746. about invokedynamic.
  747. =head2 IR
  748. See L</Intermediate Representation>
  749. =head2 IRC
  750. Internet Relay Chat. Perl 6 developers and users usually hang out on the
  751. L</#perl6> L</channel> on L</freenode>. See also
  752. L<http://perl6.org/community/irc>.
  753. =head2 ISTR
  754. I Seem To Remember.
  755. =head2 item
  756. =head2 item context
  757. =head2 Iterable
  758. =head2 iteration
  759. A way to go through all the values of an L</Iterable> object like a L</list>
  760. or a L</hash>. Generally, iterator L</object>s are invisible from user code
  761. because syntactical forms iterate for the user and pass the resulting value
  762. to the expression or the block acting on the value. Example:
  763. for 1..20 { .say }
  764. .say for 1..20
  765. =head2 IWBN
  766. It Would Be Nice.
  767. =head1 J
  768. =head2 jakudo
  769. L</Rakudo> running on the L</JVM>.
  770. =head2 JAST
  771. Intermediate representation of code used in the JVM backend of Rakudo and
  772. NQP.
  773. =head2 JIT
  774. L<Just-in-time compilation|https://en.wikipedia.org/wiki/Just-in-time_compilation>,
  775. a technique for improving the performance of virtual machines.
  776. =head2 JSON
  777. A popular data format. Its L<specification|http://json.org/> The
  778. ecosystem includes many JSON related L</projects>. Its binary
  779. counterpart is L</BSON>. The class L</JSON::Pretty> is part of the
  780. core. Thre is also support for more JSON and BSON in the L</Rakudo
  781. Star> or the L</ecosystem>.
  782. =head2 Junction
  783. A compound type that is transparent to many operations. See
  784. L<http://doc.perl6.org/type/Junction>.
  785. =head2 JVM
  786. Java Virtual Machine. The virtual machine for the Java programming language.
  787. Now many programming languages including Perl 6 have L</compiler>s targeting
  788. the JVM.
  789. =head1 K
  790. =head2 karma
  791. A measure of appreciation on L</IRC>. Karma is set by "incrementing" a pseudo:
  792. "jnthn++ # moar commit". It is purely notional on L</#perl6> and other Perl 6 related channels because L</dalek>
  793. does not track karma anymore.
  794. =head2 kebab case
  795. A naming convention where a word boundaries in a multiple word identifier is
  796. indicated with a dash (-) character. For example, "is-deeply". Popular in Lisps
  797. and Perl 6.
  798. See L</camel case>, L</snake case>.
  799. =head2 keyword
  800. An alphabetical string that has a predefined meaning in the language
  801. source code. In most languages keywords are reserved, that is they
  802. cannot be used as L</symbol>. Not in Perl 6, the compiler knows by
  803. context if an alphabetical string is a keyword, a L</function> name
  804. used for a call or a sigiless L</parameter>. This will allow to add
  805. new keywords to Perl 6 in the future without breaking existing
  806. programs.
  807. =head2 KISS
  808. L<Keep It Simple, Stupid!|https://en.wikipedia.org/wiki/KISS_principle>, a
  809. famous motto in computer science.
  810. =head1 L
  811. =head2 lambda
  812. An anonymous function. A block with explicit parameters: C<< -> $a { say
  813. $a } >> The C<< -> >> itself, or C<< <-> >> for writeable parameter.
  814. =head2 language
  815. =head2 lazy
  816. The property of a list not to evaluate elements until they are needed.
  817. =head2 laziness
  818. According to L</WP> "lazy evaluation, or call-by-need is an evaluation
  819. strategy which delays the evaluation of an expression until its value is
  820. needed (non-strict evaluation)". In Perl 6, strings and lists can be lazy
  821. but other values are not. That is, their content is evaluated when needed
  822. so they can be potentially infinite. As of January 2015, lazy strings are
  823. not supported. They may even not make the cut for the 6.0 specification.
  824. =head2 lexical
  825. Lexical properties are derived from the structure of the source code itself,
  826. not from any information from run time.
  827. =head2 lexical pad
  828. A data structure that holds the values of lexical variables.
  829. =head2 lexical scope
  830. =head2 lexical symbol
  831. =head2 lexing
  832. =head2 lexotic
  833. A dynamic operation with a lexically scoped target. For example, C<return>
  834. has a dynamic effect (it peels back the call stack), but the thing it's
  835. returning from is a lexically defined routine.
  836. =head2 lexpad
  837. Short for L</lexical pad>.
  838. =head2 LGTM
  839. Looks good to me.
  840. =head2 LHF
  841. Low Hanging Fruit.
  842. =head2 library
  843. The compilation of a L</compilation unit> of source code written in a
  844. non-dynamic language like C results in a library.
  845. =head2 LIFO
  846. L<Last In First Out|https://en.wikipedia.org/wiki/LIFO_(computing)>, a
  847. fairly common data structure in computer science. In Perl 6 arrays behave
  848. as such when used as a L</stack>. See also L</FIFO>.
  849. =head2 line noise
  850. Used to qualified unreadable code. Often used by people that don't understand
  851. the syntax of the used language. Perl is often deemed line noise, especially
  852. because of its abundance of L</metacharacters>, like L</sigil>s. For the
  853. trained reader, they are very useful because the sigil denote an associated
  854. L</role>
  855. See L</TheDamian> L</answer|http://www.linuxvoice.com/interview-damian-conway/>
  856. to the question I<Perl looks like a regular expression>.
  857. =head2 List
  858. =head2 list context
  859. =head2 list to remember
  860. A facet of a language's design that puts the onus on the user to remember
  861. which of a group of similar constructs have certain behaviors (or requires
  862. frequent consultation of documentation to the same effect.) A goal of
  863. language design is to minimize the amount of material a user must remember,
  864. by using consistent behaviors across similar constructs, or by exposing these
  865. behaviors through syntax. A natural language analogy to "list to remember"
  866. would be irregular verb conjugations.
  867. =head2 lmddgtfy
  868. Let Me DuckDuckGo That For You. L<http://lmddgtfy.net>
  869. =head2 LMGTFY
  870. Let Me Google That For You. L<http://lmgtfy.com/>
  871. =head2 local
  872. A local variable, in L</QAST>, is local to a L</frame>. A L</HLL> lexical variable
  873. 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
  874. to an executable, the value accessible thru the local, modulo some L</SSA> magic, is accessible in a processor
  875. register. There is no relationship with the local scope in Perl 5.
  876. =head2 LoL
  877. B<L>ist B<o>f B<L>ist
  878. =head2 longname
  879. Because Perl 6 has the capability of L</multiple dispatch>, several methods
  880. or subroutines may have the same name but different parameters (different in
  881. number or in type). Perl decides which routine to call by looking at the
  882. B<longname> which consists of the name of the routine and the type signature
  883. of its invocant arguments. See also L</shortname>, L</multi-method>, and
  884. L</multi-sub>.
  885. =head2 LTA
  886. Less Than Awesome.
  887. =head2 LTM
  888. See L<Longest Token Matching|http://design.perl6.org/S05.html#Longest-token_matching>.
  889. =head2 lvalue
  890. =head1 M
  891. =head2 machine code
  892. Code specific to the L</instruction set> of a hardware architecture. Compare
  893. with L</bytecode>.
  894. =head2 magic variable
  895. L<Variable|/variable> that has a behavior of its own and that is denoted by
  896. a sigiless name with a non alphanumeric character. Unlike Perl 5 that has a
  897. profusion of magic variables, Perl 6 includes only the magic variables
  898. L</$_>, L</"$/">, L</$¢> and L<$!>. They are L</block> L</scope>d and are implicitly
  899. defined at the beginning of each block.
  900. =head2 MAIN
  901. When present, a L</multi>L<sub> that is the entry point of a L</program> L</runtime>.
  902. The code in L</phaser>s intended to run at compile time are executed before MAIN.
  903. Like in Perl 5, a MAIN sub is not necessary.
  904. =head2 MAST
  905. L</MoarVM> specific L</AST>. When the Perl 6 L</backend> is MoarVM, L</QAST>, the AST obtained from early stages of
  906. L</source code> L</compilation> is converted into MAST. The MAST is then used to generate MoarVM
  907. L</bytecode>.
  908. =head2 Match
  909. L<Value|/value> resulting from a L</match>.
  910. In L</list context>, gives the positional L</capture>s list.
  911. In L</hash context>, gives the named L</capture> hash.
  912. In L</numeric context>, gives the matched string length.
  913. In L</boolean context>, gives C<True> like any non-class object.
  914. =head2 match
  915. A match is an operation that tests a L</string> against a L</grammar> or a
  916. L</regex>. and returns an L</object> of L<Match> type in case of success,
  917. otherwise a L</Nil>
  918. Matching against a C<regex> is a special case of L</smart match>ing.
  919. See also L</parse>.
  920. =head2 memory
  921. =head2 META.info
  922. A L</JSON> file that lies in the root of a L</repository> for a project written
  923. in Perl 6. It describes a project and list its dependencies.
  924. Documented in L<spec.pod|https://github.com/perl6/ecosystem/blob/master/spec.pod>.
  925. =head2 metamodel
  926. The metamodel describes some L<OO> behaviors, like where to find a
  927. L</method>. This permits implementation of different OO behaviors in the
  928. same L</VM>. The Perl 6 implementation of the metamodel is called
  929. L</6model>. The metamodel should not be confused with the
  930. L</representation>.
  931. =head2 method
  932. Methods are L</sub>s that are called with an L</invocant>.
  933. =head2 MI
  934. Multiple inheritance.
  935. =head2 mischan
  936. A case of having put a message on the wrong (IRC) channel.
  937. =head2 MMD
  938. See L</multi-method dispatch>.
  939. =head2 MoarVM
  940. A virtual machine designed specifically for L</NQP> and its L</MOP>:
  941. L</6model>. A document about MoarVM
  942. L<purpose|https://github.com/MoarVM/MoarVM/blob/master/docs/reveal.md>.
  943. MoarVM has some similarities with the Hotspot VM so you may peruse its
  944. L<glossary|http://openjdk.java.net/groups/hotspot/docs/HotSpotGlossary.html>
  945. for entries missing from the present one.
  946. =head2 modifier
  947. It is an L</adverb> that affects the behavior of a L</rule> or a
  948. L</match> The supported modifier for rules are L</:ignorecase>,
  949. L</:ignoremark>, L</:sigspace>, L</:ratchet>, and L</:Perl5>, and their
  950. respective abbreviations C<:i>, C<:s>, C<:r>, and C<:P5>.
  951. :g :ov :x :ex :pos
  952. =head2 module
  953. =head2 MOP
  954. Meta-Object Protocol.
  955. =head2 MRO
  956. Method Resolution Order.
  957. =head2 Mu
  958. The mystical class from which all other classes are derived (無).
  959. =head2 multi
  960. L</sub>s, L</method>s, or L</rule>s that have the same name but are
  961. distinguished by their signatures. Keyword that introduces them. The
  962. operation that dispatches a call to the appropriate method is called
  963. L</multi-method dispatch>.
  964. =head2 multiple dispatch
  965. Dynamically selecting which routine to execute based on name and type of
  966. arguments.
  967. =head2 multi-method
  968. =head2 multi-sub
  969. =head2 multi-method dispatch
  970. =head2 mumble
  971. Placeholder; something that's left unclear deliberately. Either because the
  972. speaker doesn't know or because it's an unimportant detail.
  973. =head2 my
  974. =head2 MY::
  975. A L</pseudo-scope> to access L</symbol>s in the current L</lexical scope>
  976. (aka $?SCOPE).
  977. =head1 N
  978. =head2 named parameter
  979. =head2 namespace
  980. =head2 native
  981. Something that does not pertain the Perl interpreter proper but
  982. to the L</backend> or the underlying system.
  983. See also: L</pure Perl>
  984. =head2 Native Call
  985. Calling a routine from an external C/C++ library, provided by the
  986. NativeCall library (which is now bundled with L</Rakudo>).
  987. =head2 Native value
  988. A native value is an L</int>, L</num>, L</str>. A native value cannot be
  989. undefined.
  990. =head2 name
  991. Syntactical convention to denote an entity in a program source code. Such an
  992. entity can be a routine, a variable... See also : L</symbol>, L</scope>,
  993. L</sigil>, L</role>, L</adverbial pair>.
  994. =head2 NC
  995. L</Native Call>
  996. =head2 NCI
  997. L</Native Call> Interface
  998. =head2 need
  999. =head2 NFA
  1000. Nondeterministic Finite Automaton, an algorithmic technique used by the
  1001. regex engine. See:
  1002. L<https://en.wikipedia.org/wiki/Nondeterministic_finite_automaton>.
  1003. =head2 NFG
  1004. Proposed L</Unicode Normalization Form> for Perl 6, in which composed
  1005. characters always get their own codepoint. If a codepoint doesn't exist for
  1006. that composed character, one is assigned dynamically.
  1007. Documentation for this can hypothetically be found in L<S15>.
  1008. =head2 Niecza
  1009. An implementation of Perl 6 targeting the .NET platform.
  1010. =head2 Nil
  1011. Means there is no value. This is different from C<()>, the L</empty list>.
  1012. =head2 NST
  1013. No Such Thing.
  1014. =head2 nom
  1015. The name of the main branch of current L</Rakudo> in L</git>. Originally
  1016. named so for its "new object model".
  1017. =head2 Normalization Form
  1018. =head2 NPE
  1019. Null Pointer Exception.
  1020. =head2 null-PMC access
  1021. =head2 Num
  1022. =head2 number
  1023. =head2 numeric context
  1024. =head2 NQP
  1025. Short for B<N>ot B<Q>uite B<P>erl, a subset of Perl 6 suitable for tasks
  1026. such as implementing L</Rakudo>. Targets L</Parrot>, the L</JVM> and
  1027. L</MoarVM>.
  1028. =head2 NSA
  1029. Native, Shaped Arrays.
  1030. =head1 O
  1031. =head2 obfuscation
  1032. Code deliberately unreadable often using esoteric language features.
  1033. Sometimes combined with L</golfing>.
  1034. =head2 object
  1035. =head2 object code
  1036. For non L</dynamic language>s, from a L</compilation unit>, the L</compiler>
  1037. generates object code or library. A latter phase links object code to
  1038. generate an executable. For dynamic languages like Perl 6, the equivalent
  1039. of object code is the L</bytecode> and the linking phase is more complex and
  1040. involves the deL</serialization> of information.
  1041. =head2 On Stack Replacement
  1042. According to the hotspot
  1043. L<glossary|http://openjdk.java.net/groups/hotspot/docs/HotSpotGlossary.html>:
  1044. The process of converting an interpreted (or less optimized) L</stack frame>
  1045. into a compiled (or more optimized) stack frame.
  1046. =head2 OO
  1047. Object oriented. See L</OOP>.
  1048. =head2 OOP
  1049. Acronym for L<Object-oriented programming|https://en.wikipedia.org/wiki/Object-oriented_programming>.
  1050. =head2 op
  1051. Ops are L</opcode>s that belong to the L</NQP> L<interpreter> or that are
  1052. dynamically charged by the interpreter of another language. The word L</extops>
  1053. is used to denote the latter ops
  1054. =head2 opcode
  1055. An opcode is an instruction in a L</bytecode> or L</AST>. Documentation about L</MoarVM>
  1056. L<opcodes|https://github.com/MoarVM/MoarVM/blob/master/docs/bytecode.markdown>.
  1057. =head2 open source
  1058. =head2 operand
  1059. See L</operator>.
  1060. =head2 operating system
  1061. =head2 operator
  1062. An expression is made of operators and operands. More precisely it is made
  1063. of an operator and operands that can be subexpressions or L</value>s.
  1064. Operators are an alternative syntax for a L</multi-method>. With that
  1065. syntax, what would be the L</argument>s of the function are named operands
  1066. instead. Operators are classified into
  1067. L<categories|http://design.perl6.org/S02.html#Grammatical_Categories> of
  1068. categories. A category has a precedence, an arity, and can be L</fiddly>,
  1069. L</iffy>, L</diffy>. Perl 6 is very creative as to what is an operator, so
  1070. there are many categories. Operators are made of many tokens, possibly with
  1071. a subexpression. For example, C<@a[0]> belongs to the postcircumfix
  1072. category, is broken into the operand C<@a> and the postcircumfix operator
  1073. C<[0]> where C<0> is the postcircumfixed subexpression.
  1074. The C<< <O(I<...>)> >> construction gives information about an operator
  1075. that completes the information provided by its category. Below
  1076. C<%conditional> is the category, C<< :reducecheck<ternary> >>, which
  1077. specifies calling C<.ternary> to post-process the L<parse subtree|/parse
  1078. tree> and C<< :pasttype<if> >> specifies the NQP L</opcode> generated in the
  1079. L</AST> from the parse subtree.
  1080. <O('%conditional, :reducecheck<ternary>, :pasttype<if>')>
  1081. =head2 opt
  1082. An optimization, usually in either the context of L</spesh> or L</JIT>.
  1083. =head2 OS
  1084. Operating system. See L<http://en.wikipedia.org/wiki/Operating_system>.
  1085. =head2 OSR
  1086. L</On Stack Replacement>
  1087. =head2 our
  1088. =head2 OUR::
  1089. A L</pseudo-scope> to access L</symbol>s in the current package (aka $?PACKAGE).
  1090. =head2 OUTER::
  1091. A L</pseudo-scope> to access L</symbol>s in the next outer L</lexical scope>.
  1092. =head1 P
  1093. =head2 package
  1094. =head2 package manager
  1095. See L</project manager>
  1096. =head2 pad
  1097. See L</lexical …

Large files files are truncated, but you can click here to view the full file