txt: ## glossary.md
  ## Chunk 1 of 2
  Glossary
  
  Glossary of Raku terminology
  
  # [Abstract class](#Glossary "go to top of document")[§](#Abstract_class "direct link")
  
  The generic Computer Science term "abstract class" defines the [interface](#Interface) or [API](#API) of a class. In Raku, this is implemented using [roles](#Roles) with [stubbed](#Stub) methods.
  
  ```raku
  role Canine {
      method bark { ... }          # the ... indicates a stub
  }
  
  class Dog does Canine {
      method bark { say "woof" }   # *MUST* be implemented by class
  }
  ```
  
  # [Advent calendar](#Glossary "go to top of document")[§](#Advent_calendar "direct link")
  
  In the context of Raku, a yearly set of blog posts for each day from the 1st until the 25th of December, to be found at <https://raku-advent.blog>.
  
  # [Adverb](#Glossary "go to top of document")[§](#Adverb "direct link")
  
  Generically, an adverb is a named argument to a function. There are also some specific syntax forms that allow adverbs to be tucked into some convenient places:
  
  ```raku
  q:w"foo bar";   # ":w" is a Quotelike form modifier adverb
  m:g/a|b|c/;     # ":g" is too
  @h{3}:exists;   # ":exists" is too, but is known as a subscript adverb
  
  ```
  
  Adverbs are usually expressed with colon pair notation, and for this reason colon pair notation is also known as the adverbial pair form:
  
  ```raku
  :a(4)          # Same as "a" => 4
  ```
  
  Some other forms that use a colon in ways that have adverb-like semantics are called adverbial forms. One special form starts with an integer value, followed by a name (for the key):
  
  ```raku
  :20seconds     # same as seconds => 20
  ```
  
  Also see [Colon pair and colon list](#Colon_pair_and_colon_list).
  
  # [Adverbial pair](#Glossary "go to top of document")[§](#Adverbial_pair "direct link")
  
  A generalized form of `pair notation`. They all start with the colon, as shown in the following examples:
  
  | adverbial pair | pair notation |
  | --- | --- |
  | :foo<bar> | foo => 'bar' |
  | :foo(42) | foo => 42 |
  | :42foo | foo => 42 |
  | :$foo | foo => $foo |
  | :foo | foo => True |
  | :!foo | foo => False |
  
  Also see [Adverb](#Adverb) and [Colon pair and colon list](#Colon_pair_and_colon_list).
  
  # [Allomorph](#Glossary "go to top of document")[§](#Allomorph "direct link")
  
  A type that has two related values which may be used depending on the context. For example [`IntStr`](/type/IntStr) allomorph `is` both an [`Int`](/type/Int) and a [`Str`](/type/Str), so it will be accepted by anything that expects an [`Int`](/type/Int), a [`Str`](/type/Str), or an [`IntStr`](/type/IntStr). Keep in mind that certain constructs, such as [sets, bags, and mixes](/language/setbagmix) care about object identity, and so will not accept an allomorph as equivalent of its components alone.
  
  The *allomorph* types [`IntStr`](/type/IntStr), [`NumStr`](/type/NumStr), [`RatStr`](/type/RatStr) and [`ComplexStr`](/type/ComplexStr) may be created as a result of parsing a string quoted with angle brackets:
  
  ```raku
  say <42>.^name;     # OUTPUT: «IntStr␤»
  say <42.1e0>.^name; # OUTPUT: «NumStr␤»
  say <42.1>.^name;   # OUTPUT: «RatStr␤»
  ```
  
  **Note**: angle brackets can also be used to create literals for which you'd normally need to use some operator (e.g. `/` for [`Rat`](/type/Rat) or `+` for [`Complex`](/type/Complex)). This allows you to use such literals in places where expressions are not allowed, for example, as literals in signatures:
  
  ```raku
  # Wrong, can't use an operator there:
  multi foo (1/3) { say "It's one third!" }
  
  ```
  
  ```raku
  # Right, a Rat literal:
  multi foo (<1/3>) { say "It's one third!" }
  
  ```
  
  If you *do* want an allomorph and not a literal [`Numeric`](/type/Numeric), then include whitespace around angle brackets:
  
  ```raku
  say <42/1>.^name;    # OUTPUT: «Rat␤»
  say <42+0i>.^name;   # OUTPUT: «Complex␤»
  say < 42+0i >.^name; # OUTPUT: «ComplexStr␤»
  say < 42/1 >.^name;  # OUTPUT: «RatStr␤»
  ```
  
  Please see [the Numerics page](/language/numerics#Allomorphs) for a more complete description on how to work with these allomorphs.
  
  # [Anonymous](#Glossary "go to top of document")[§](#Anonymous "direct link")
  
  A subroutine, method or submethod is called *anonymous* if it can't be called by name.
  
  ```raku
  # named subroutine
  sub double($x) { 2 * $x };
  
  # anonymous subroutine, stored in a named scalar
  my $double = sub ($x) { 2 * $x };
  ```
  
  Note that it is still allowed to have a name, but you cannot call it by that name:
  
  ```raku
  # anonymous, but knows its own name
  my $s = anon sub triple($x) { 3 * $x }
  say $s.name;        # OUTPUT: «triple␤»
  
  ```
  
  ```raku
  say triple(42);     # OUTPUT: «Undeclared routine: triple␤»
  
  ```
  
  # [API](#Glossary "go to top of document")[§](#API "direct link")
  
  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 the implementation details.
  
  See also [abstract class](#Abstract_class).
  
  # [Apocalypse](#Glossary "go to top of document")[§](#Apocalypse "direct link")
  
  A document originally written by [TimToady](#TimToady), in which he processed the initial barrage of RFCs that came out of the Perl community. Now only kept as a historical document for reference. See also [Exegesis](#Exegesis) and [Synopsis](#Synopsis).
  
  # [Arity](#Glossary "go to top of document")[§](#Arity "direct link")
  
  The number of [`Positional`](/type/Positional) operands expected by an [operator](#Operator), subroutine, method or callable block.
  
  ```raku
  sub infix:<+>(Foo $a, Foo $b) { $a.Int + $b.Int }  # arity of "+" is 2
  sub frobnicate($x) { ... }                         # arity of 1
  sub the-answer() { 42 }                            # arity of 0
  -> $key, $value { ... }                            # arity of 2
  
  ```
  
  The arity of a [`Callable`](/type/Callable) is one of the main selectors in [multi-dispatch](#Multi-dispatch).
  
  # [ASCII operator](#Glossary "go to top of document")[§](#ASCII_operator "direct link")
  
  The ASCII variant of a non-ASCII Unicode [operator](#Operator) or [symbol](#Symbol). For instance, `(elem)` corresponds to the `∈` ("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](/language/unicode_ascii). Well, maybe just a little...
  
  # [Autothreading](#Glossary "go to top of document")[§](#Autothreading "direct link")
  
  Autothreading is what happens if you pass a [`Junction`](/type/Junction) to a subroutine that expects a parameter of type [`Any`](/type/Any) or a subtype thereof (such as anything [`Cool`](/type/Cool)). The call is then executed for each value of the junction. The result of these calls is assembled in a new junction of the same type as the original junction.
  
  ```raku
  sub f($x) { 2 * $x };
  say f(1|2|3) == 4;    # OUTPUT: «any(False, True, False)␤»
  ```
  
  Here `f()` is a sub with one parameter, and since it has no explicit type, it is implicitly typed as [`Any`](/type/Any). The [`Junction`](/type/Junction) argument causes the `f(1|2|3)` call to be internally executed as `f(1)|f(2)|f(3)`, and the resulting junction is `2|4|6`. These are then all compared to `4`, resulting in a junction `False|True|False`. This process of separating junction arguments into multiple calls to a function is called *autothreading*.
  
  If you use the resulting junction in a Boolean context, such as with an `if`, it collapses into a single Boolean which is `True` if any of the values in the junction are True.
  
  ```raku
  if f(1|2|3) == 4 {    # fires because f(2) == 4 is true
      say 'success';
  }
  
  ```
  
  # [Backtracking](#Glossary "go to top of document")[§](#Backtracking "direct link")
  
  Backtracking is the default way a regexp is matched. The engine is allowed to explore several ways moving backward in the string characters in order to allow every piece of a regexp to match something. For more information, see [Regexp Backtracking section](/language/regexes#Backtracking).
  
  # [binder](#Glossary "go to top of document")[§](#binder "direct link")
  
  When you pass an argument list to a function (or any other callable, like a method or a block), the argument list gets bound to the parameters in the signature. The code that does this is called the *binder*.
  
  # [block](#Glossary "go to top of document")[§](#block "direct link")
  
  [Blocks](/type/Block) are code object with its own lexical scope, which allows them to define variables without interfering with other in the containing block.
  
  # [bytecode](#Glossary "go to top of document")[§](#bytecode "direct link")
  
  Although Raku looks like an interpreted language, since it uses the `#!` form to run its scripts (and they are called *scripts*), it is actually [compiled to run in a virtual machine](https://www.reddit.com/r/perl6/comments/42dkme/perl6_not_being_an_interpreted_language/) so the compiler (currently Rakudo) generates [bytecode](https://en.wikipedia.org/wiki/Bytecode) that runs either in MoarVM or the Java Virtual Machine, the two VMs currently supported.
  
  # [Camelia](#Glossary "go to top of document")[§](#Camelia "direct link")
  
  A butterfly image intended primarily to represent Raku, The Language.
  
  # [Colon pair and colon list](#Glossary "go to top of document")[§](#Colon_pair_and_colon_list "direct link")
  
  A colon pair is a shorthand syntax used to create or visually present a [`Pair`](/type/Pair) object. The two most common forms are:
  
  ```raku
  :a(4)          # Same as "a" => 4,   same as Pair.new("a", 4)
  :a<4>          # Same as "a" => "4", same as Pair.new("a", val("4"))
  ```
  
  This is also known as the adverbial pair form.
  
  **Note**: when the part after the colon and before the balanced delimiters is not a legal identifier, other semantics apply, not all of which produce [`Pair`](/type/Pair) objects.
  
  Two other common forms are:
  
  ```raku
  :a             # Same as :a(True)
  :!a            # Same as :a(False)
  ```
  
  A colon list just means that a list that contains only colon pairs, does not need commas, or even spaces:
  
  ```raku
  :a(4):c:!d:c   # Same as a => 4, c => True, d => False, c => True
  ```
  
  Finally, if there is a variable with the same name as an intended adverbial pair, you don't have to specify the name twice, but just specify the adverb with the appropriate sigil:
  
  | variable only | same as |
  | --- | --- |
  | :$foo | foo => $foo |
  | :@bar | bar => @bar |
  | :%mapper | mapper => %mapper |
  | :&test | test => &test |
  
  See also [Adverb](#Adverb).
  
  # [Community](#Glossary "go to top of document")[§](#Community "direct link")
  
  See <https://raku.org/community/> for information about how to participate in the friendly Raku community.
  
  # [Damian Conway](#Glossary "go to top of document")[§](#Damian_Conway "direct link")
  
  Original author of the [Exegesis](#Exegesis) (among many other things). See also <https://en.wikipedia.org/wiki/Damian_Conway>.
  
  # [decont](#Glossary "go to top of document")[§](#decont "direct link")
  
  Short for "decontainerize", meaning to remove an item [from its `Scalar` container](/language/containers), often to obtain [a different behavior](https://perl6advent.wordpress.com/2017/12/02/#theoneandonly) for items that have it.
  
  # [diffy](#Glossary "go to top of document")[§](#diffy "direct link")
  
  See [operator](#Operator). It means the type of the operator result is sufficiently different from its arguments that op= makes little sense.
  
  # [Exegesis](#Glossary "go to top of document")[§](#Exegesis "direct link")
  
  A document originally written by [TheDamian](#TheDamian), in which he tried to explain the [Apocalypses](#Apocalypse) to the common (wo)man. Now only kept as a historical document for reference. See also [Synopsis](#Synopsis).
  
  # [Forward declarations](#Glossary "go to top of document")[§](#Forward_declarations "direct link")
  
  Declare the scope and/or type of a functional entity (class or routine) without actually declaring its code by using the ["stub" operator](/language/operators#listop_...); code will be declared later on in the same file.
  
  ```raku
  grammar Quux {
      my regex future {...};
      say "foobarbaz" ~~ /<future>/;
      regex future { f \w** 2 b \w ** 2 }
  }
  
  ```
  
  In this case, the regex acts as a method; please note that the scope is only declared once.
  
  # [fiddly](#Glossary "go to top of document")[§](#fiddly "direct link")
  
  Too complicated to apply a metaop to. See [operator](#Operator).
  
  # [Handle](#Glossary "go to top of document")[§](#Handle "direct link")
  
  A handle is a data structure used to store information about some input/output operation such as file or socket reading or writing. Raku uses [`IO::Handle`](/type/IO/Handle) as a base class for filehandles, and [`IO::Socket`](/type/IO/Socket) for sockets.
  
  # [Huffmanize](#Glossary "go to top of document")[§](#Huffmanize "direct link")
  
  With reference to [Huffman coding](https://en.wikipedia.org/wiki/Huffman_coding), "huffmanizing" is making things that are commonly used easier, and often shorter, to type. With things that are used less frequently it's both less of a bother to type longer pieces of code and often longer, more descriptive naming is necessary to easily be reminded of what the rarely-used feature does.
  
  For example, printing output is a common task, while performing thread-safe atomic addition on native atomicity-safe integers is much less so. There's a need to "huffmanize" the task printing and that's why you can do it by just typing three letters [put](/routine/put). But there's no need to "huffmanize" the rarely-needed atomic operators, which is why you type the lengthier names, such as [atomic-inc-fetch](/routine/atomic-inc-fetch). The name [put](/routine/put) is a bit vague, but because it's commonly used, it's easy to learn what it does. On the other hand, the name [atomic-inc-fetch](/routine/atomic-inc-fetch) is rarer, and the more descriptive name helps recall its purpose better.
  
  # [iffy](#Glossary "go to top of document")[§](#iffy "direct link")
  
  Often used as a Boolean value. See [operator](#Operator). Made via the [`use` keyword](/language/modules#use).
  
  # [import](#Glossary "go to top of document")[§](#import "direct link")
  
  Include functions from a module in the current namespace.
  
  # [infix stopper](#Glossary "go to top of document")[§](#infix_stopper "direct link")
  
  An *infix stopper* is something that tells us the grammar not try to parse an infix at that point. Consider say `"abc42def" ~~ m|\d+|`. Ordinarily, a `|` in a regex is treated as an alternation, but since the infix stopper matches the current regex terminator, we don't continue and try to parse an infix at that point. The `|` is thus treated as the end of the regex.
  
  # [Instance](#Glossary "go to top of document")[§](#Instance "direct link")
  
  An *instance* of a class is also called an *object* in some other programming languages. It has storage for attributes and is often the return value of a call to a method called `new`, or a literal.
  
  Instances of most types are defined to be `True` e.g., `defined($instance)` is `True`.
  
  ```raku
  my Str $str = "hello";  ## this is with built-in types, e.g. Str
  if defined($str) {
      say "Oh, yeah. I'm defined.";
  }
  else {
      say "No. Something off? ";
  }
  
  ## if you wanted objects...
  class A {
      # nothing here for now.
  }
  
  my $an_instance = A.new;
  say $an_instance.defined.raku;# defined($an_instance) works too.
  ```
  
  To put things another way, a class contains the blueprints of methods and attributes, and an instance carries it into the real world.
  
  # [Interface](#Glossary "go to top of document")[§](#Interface "direct link")
  
  An interface is an [abstract class](#Abstract_class).
  
  # [Invocant](#Glossary "go to top of document")[§](#Invocant "direct link")
  
  Caller, *the one who calls or invokes*. The invocant of a method would be the object on which that method is being called, or, in some cases, the class itself. *Invocant* is used instead of caller because the latter refers to the *scope*.
  
  # [IRC](#Glossary "go to top of document")[§](#IRC "direct link")
  
  Internet Relay Chat. Raku developers and users usually hang out on the `#raku` channel of `irc.libera.chat`. This channel is also populated by a host of friendly bots that allow you to interact with Raku and its codebase, as well as send delayed messages and other goodies. Check the full list in [the community page of raku.org](https://raku.org/community/irc).
  
  # [IRC lingo](#Glossary "go to top of document")[§](#IRC_lingo "direct link")
  
  The following terms are often used on the Raku related [IRC](#IRC) channels:
  
  ## [ALAP](#Glossary "go to top of document")[§](#ALAP "direct link")
  
  As Late As Possible
  
  ## [autopun](#Glossary "go to top of document")[§](#autopun "direct link")
  
  A self-referencing pun, e.g. "Are you ignorant or apathetic?" - "I don't know, and I don't care."
  
  ## [backlog](#Glossary "go to top of document")[§](#backlog "direct link")
  
  That part of a discussion on an [IRC](#IRC) channel that you've missed. If it is not or no longer available in your IRC client, you can go to sites such as <https://irclogs.raku.org> to see what has been logged for you.
  
  ## [Bot](#Glossary "go to top of document")[§](#Bot "direct link")
  
  A program that does automatic tasks on one or more [IRC](#IRC) channels by acting like a regular user (as far as the IRC server is concerned) and performing some tasks that may involve answering to users requests. Examples can be found [on the IRC page of raku.org](https://raku.org/community/irc).
  
  ## [Compilation unit or *compunit*](#Glossary "go to top of document")[§](#Compilation_unit_or_compunit "direct link")
  
  A [compunit](https://github.com/rakudo/rakudo/blob/master/docs/module_management.md) is a piece of Raku code that is analyzed and compiled as a single unit. Typically, this piece of code will be contained in a single file, but code inside an [EVAL](/routine/EVAL) is also considered a compunit.
  
  ## [DWIM](#Glossary "go to top of document")[§](#DWIM "direct link")
  
  *Do What I Mean*. A programming language designer motto. The opposite of a DWIM is a [WAT](#WAT).
  
  ## [flap](#Glossary "go to top of document")[§](#flap "direct link")
  
  Sometimes a test will fail under some conditions, but not others; when this test passes in some test runs and fails in others, it's called flapping.
  
  ## [fossil](#Glossary "go to top of document")[§](#fossil "direct link")
  
  Something in a generally current document that is no longer true but which has not yet been fixed by correcting or removing it.
  
  ## [FSVO](#Glossary "go to top of document")[§](#FSVO "direct link")
  
  For Some Value Of...
  
  ## [FTFY](#Glossary "go to top of document")[§](#FTFY "direct link")
  
  Fixed That For You
  
  ## [gradual typing](#Glossary "go to top of document")[§](#gradual_typing "direct link")
  
  You don't have to specify types of variables and parameters, but if you do, it helps in early determination of impossible dispatches and better optimization. See also <https://en.wikipedia.org/wiki/Gradual_typing>.
  
  ## [IIRC](#Glossary "go to top of document")[§](#IIRC "direct link")
  
  If I Read (or Remember) Correctly.
  
  ## [IMHO](#Glossary "go to top of document")[§](#IMHO "direct link")
  
  In My Humble Opinion.
  
  ## [IWBN](#Glossary "go to top of document")[§](#IWBN "direct link")
  
  It Would Be Nice
  
  ## [LHF](#Glossary "go to top of document")[§](#LHF "direct link")
  
  Low Hanging Fruit. Usually used in the context of a (relatively) simple task to be performed by a (relative) newbie.
  
  ## [LGTM](#Glossary "go to top of document")[§](#LGTM "direct link")
  
  Looks Good To Me
  
  ## [LTA](#Glossary "go to top of document")[§](#LTA "direct link")
  
  Less Than Awesome. Usually used in the context of an error message that is rather non-descriptive or unrelated to the actual error.
  
  ## [NST](#Glossary "go to top of document")[§](#NST "direct link")
  
  No Such Thing
  
  ## [Opt](#Glossary "go to top of document")[§](#Opt "direct link")
  
  Short for "optimization", usually in either the context of [spesh](#Spesh) or JIT.
  
  ## [PB](#Glossary "go to top of document")[§](#PB "direct link")
  
  Short for "problem". As in "that's not the pb".
  
  ## [PR](#Glossary "go to top of document")[§](#PR "direct link")
  
  See [Pull request](#Pull_request).
  
  ## [P5](#Glossary "go to top of document")[§](#P5 "direct link")
  
  Perl 5
  
  ## [P6](#Glossary "go to top of document")[§](#P6 "direct link")
  
  Raku (née Perl 6)
  
  ## [RSN](#Glossary "go to top of document")[§](#RSN "direct link")
  
  Real Soon Now.
  
  ## [RT](#Glossary "go to top of document")[§](#RT "direct link")
  
  Request Tracker (<https://rt.perl.org/>). The place where all the bugs related to [Rakudo](#Rakudo) used to live. Nowadays, the Github issue tracker of the rakudo/rakudo repository is used for that.
  
  ## [TIMTOWTDI](#Glossary "go to top of document")[§](#TIMTOWTDI "direct link")
  
  An alternative form of [TIMTOWTDI](#TMTOWTDI), explicitly including the "is" from the contraction "There's".
  
  ## [TMI](#Glossary "go to top of document")[§](#TMI "direct link")
  
  Too Much Information.
  
  ## [TMTOWTDI](#Glossary "go to top of document")[§](#TMTOWTDI "direct link")
  
  "There's More Than One Way To Do It", the Perl motto.
  
  ## [UGT](#Glossary "go to top of document")[§](#UGT "direct link")
  
  "Universal Greeting Time" - i.e., it's always "morning".
  
  ## [WFM](#Glossary "go to top of document")[§](#WFM "direct link")
  
  Works For Me
  
  ## [WIP](#Glossary "go to top of document")[§](#WIP "direct link")
  
  Work In Progress
  
  ## [WP](#Glossary "go to top of document")[§](#WP "direct link")
  
  Wikipedia
  
  ## [WW](#Glossary "go to top of document")[§](#WW "direct link")
  
  Short for `wrong window`. When on [IRC](#IRC), someone types something in a channel that was intended for another channel, or for a private message.
  
  # [Larry Wall](#Glossary "go to top of document")[§](#Larry_Wall "direct link")
  
  [Perl's](#Perl) benevolent dictator for life, among many other things. See also <https://en.wikipedia.org/wiki/Larry_Wall>.
  
  # [Lexing](#Glossary "go to top of document")[§](#Lexing "direct link")
  
  Performing [lexical analysis](https://en.wikipedia.org/wiki/Lexical_analysis), a step which usually precedes parsing.
  
  # [Literal](#Glossary "go to top of document")[§](#Literal "direct link")
  
  A *literal* is a piece of code that directly stands for an (often built-in) object and also refers to the object itself.
  
  ```raku
  my $x = 2;      # the 2 is a literal
  say $x;         # $x is not a literal, but a variable
  my $s = "Foo";  # the "Foo" is a literal, the $s is a variable
  ```
  
  Different types of literals are described in [the syntax document](/language/syntax#Literals).
  
  # [LHS](#Glossary "go to top of document")[§](#LHS "direct link")
  
  As an acronym left-hand side, it usually refers to the left hand side of an expression, and more specifically to the left-hand side of expressions such as `$lhs = "this would be the right-hand side"`. Since the left hand side of these expressions modify their value, when something behaves as a LHS it means that it can be read and written to.
  
  # [lvalue](#Glossary "go to top of document")[§](#lvalue "direct link")
  
  An *lvalue*, or a *left value*, is anything that can appear on the left-hand side of the assignment operator `=`. It is anything you can assign to.
  
  Typical lvalues are variables, private and `is rw` attributes, lists of variables and lvalue subroutines.
  
  Examples of lvalues:
  
  | Declaration | lvalue | Comments |
  | --- | --- | --- |
  | my $x; | $x |  |
  | my ($a, $b); | ($a, $b) |  |
  | has $!attribute; | $!attribute | Only inside classes |
  | has $.attrib is rw; | $.attrib |  |
  | sub a is rw { $x }; | a() |  |
  
  Examples of things that are not lvalues:
  
  |  |  |
  | --- | --- |
  | 3 | literals |
  | constant x = 3; | constants |
  | has $.attrib; | attributes; you can only assign to $!attrib |
  | sub f { }; f(); | "normal" subs are not writable |
  | sub f($x) { $x = 3 }; | error - parameters are read-only by default |
  
  These are typically called [rvalues](#rvalue).
  
  # [Mainline](#Glossary "go to top of document")[§](#Mainline "direct link")
  
  The `mainline` is the program text that is not part of any kind of block.
  
  ```raku
  use v6.c;     # mainline
  sub f {
                # not in mainline, in sub f
  }
  f();          # in mainline again
  
  ```
  
  You can also have the mainline of any package-like declarator, such as class, [module](/language/modules), [grammar](/language/grammars), etc. These are typically run just after the class/module/grammar have been compiled (or when loaded from a precompiled file).
  
  # [Mayspec](#Glossary "go to top of document")[§](#Mayspec "direct link")
  
  Stands for "Maybe Specification". Usually refers to existing tests in the [language specification](https://github.com/Raku/roast/). The speaker is indicating they did not check whether the test is a spectest or a propspec test; i.e., whether the test is included in a released language specification or is a new test, proposed for the next version of the spec.
  
  # [MoarVM](#Glossary "go to top of document")[§](#MoarVM "direct link")
  
  MoarVM is short for Metamodel On A Runtime Virtual Machine. It's a virtual machine designed specifically for [NQP](#NQP) and its [MOP](/language/mop): [6model](#6model). A document about [the purpose of MoarVM](https://github.com/MoarVM/MoarVM/blob/master/docs/reveal.md). MoarVM has some similarities with the Hotspot VM so you may peruse its [glossary](http://openjdk.java.net/groups/hotspot/docs/HotSpotGlossary.html) for entries missing from the present one.
  
  # [Multi-dispatch](#Glossary "go to top of document")[§](#Multi-dispatch "direct link")
  
  The mechanism used to invoke different routines ([`Method`](/type/Method)s or [`Sub`](/type/Sub)s) of the same name, selecting the correct one based on the [`Parameter`](/type/Parameter) prototype and the arguments it was called with.
  
  The selection process is primarily based on types and number of arguments ([arity](#Arity)), where the narrowest, most specific candidate wins, typically without regard to the order of declaration. The `is default` trait may be used as a tie breaker in this first phase. There is also a secondary phase where some different tie breakers may be evaluated in order of declaration of the methods or subs.
  
  # [multi-method](#Glossary "go to top of document")[§](#multi-method "direct link")
  
  A [method](/type/Method) that has multiple candidates going by the same name and are subject to [Multi-Dispatch](#Multi-dispatch).
  
  # [Née](#Glossary "go to top of document")[§](#Née "direct link")
  
  "Formerly known as".
  
  # [NFG](#Glossary "go to top of document")[§](#NFG "direct link")
  
  Normal Form Grapheme is the way Raku implements graphemes, using a normal form in which strings with the same graphemes can be easily compared in constant time. More on that on [these articles](https://6guts.wordpress.com/2015/04/12/this-week-unicode-normalization-many-rts/) [in 6guts](https://6guts.wordpress.com/2015/04/20/this-week-digging-into-nfg-fixing-use-fatal-and-more/) and a fun explanation of how NFG works in [this IRC log](https://irclogs.raku.org/perl6/2018-04-29.html#16:57-0002).
  
  # [Niecza](#Glossary "go to top of document")[§](#Niecza "direct link")
  
  An implementation of Raku targeting the .NET platform. No longer actively maintained.
  
  # [Not Quite Perl](#Glossary "go to top of document")[§](#Not_Quite_Perl "direct link")
  
  See [NQP](#NQP).
  
  # [NQP](#Glossary "go to top of document")[§](#NQP "direct link")
  
  NQP is a primitive language for writing subroutines and methods using a subset of the Raku syntax. It's not intended to be a full-fledged programming language, nor does it provide a runtime environment beyond the basic VM primitives. Compilers (such as [Rakudo](#Rakudo)) typically use NQP to compile action methods that convert a parse tree into its equivalent abstract syntax tree representation.
  
  # [NYI](#Glossary "go to top of document")[§](#NYI "direct link")
  
  Not Yet Implemented
  
  # [opcode](#Glossary "go to top of document")[§](#opcode "direct link")
  
  An opcode, or operation code, is a bytecode operation, that is, a command of the language actually used on the virtual machine. They are not usually intended for human consumption, but they are usually specified somewhere, like [this document for MoarVM](https://github.com/MoarVM/MoarVM/blob/master/docs/bytecode.markdown).
  
  # [Operator](#Glossary "go to top of document")[§](#Operator "direct link")
  
  An expression is made of operators and operands. More precisely it is made of an operator and operands that can be subexpressions or [value](#value)s. Operators are an alternative syntax for a [multi-method](#multi-method). With that syntax, what would be the arguments of the function are named operands instead. Operators are classified into [categories](https://github.com/Raku/old-design-docs/blob/master/S02-bits.pod#Grammatical_Categories) of categories. A category has a precedence, an arity, and can be [fiddly](#fiddly), [iffy](#iffy), [diffy](#diffy). Raku 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, `@a[0]` belongs to the postcircumfix category, is broken into the operand `@a` and the postcircumfix operator `[0]` where `0` is the postcircumfixed subexpression.
  
  The `<O(I<...>)>` construction gives information about an operator that completes the information provided by its category. Below `%conditional` is the category, `:reducecheck<ternary>`, which specifies calling `.ternary` to post-process the [parse subtree](#Parse_tree) and `:pasttype<if>` specifies the NQP [opcode](#opcode) generated in the AST from the parse