txt: ## glossary.md
  ## Chunk 2 of 2
   subtree.
  
  ```raku
  <O('%conditional, :reducecheck<ternary>, :pasttype<if>')>
  ```
  
  # [Parse tree](#Glossary "go to top of document")[§](#Parse_tree "direct link")
  
  A [parse tree](https://en.wikipedia.org/wiki/Parse_tree) represents the structure of a string or sentence according to a grammar. [`Grammar`](/type/Grammar)s in Raku output parse trees when they successfully match a string.
  
  # [Parameter](#Glossary "go to top of document")[§](#Parameter "direct link")
  
  [`Parameter`](/type/Parameter) is a class to define parameters to [`Sub`](/type/Sub)routines, [`Method`](/type/Method)s and [`Callable`](/type/Callable) blocks. As opposed to the arguments you specify when calling a subroutine/method/callable block.
  
  ```raku
  sub foo($bar) { say $bar }     # $bar is a parameter
  foo(42);                       # 42 is an argument
  ```
  
  # [Parrot](#Glossary "go to top of document")[§](#Parrot "direct link")
  
  A [virtual machine](#Virtual_machine) designed to run Raku and other dynamic languages. No longer actively maintained.
  
  # [PAST](#Glossary "go to top of document")[§](#PAST "direct link")
  
  [Parrot](#Parrot) AST.
  
  # [Perl](#Glossary "go to top of document")[§](#Perl "direct link")
  
  The Perl programming language.
  
  # [Perl 6](#Glossary "go to top of document")[§](#Perl_6 "direct link")
  
  The name used for Raku before October 2019.
  
  # [PERL](#Glossary "go to top of document")[§](#PERL "direct link")
  
  A way to describe [Perl](#Perl) as a language, considered to be improper by many in the [Perl Community](/language/community).
  
  # [POD](#Glossary "go to top of document")[§](#POD "direct link")
  
  **P**lain **O**l' **D**ocumentation, a documentation format understood by Raku. See [here](/language/pod) for further information.
  
  # [POV](#Glossary "go to top of document")[§](#POV "direct link")
  
  Stands for "Proof Of Viability". To be included in the language specification, a "proof of viability" implementation of the feature must exist in at least one mostly-compliant Raku compiler.
  
  # [Propspec](#Glossary "go to top of document")[§](#Propspec "direct link")
  
  Stands for "Proposed Specification". Usually refers to existing tests in the [language specification](https://github.com/Raku/roast/) that are proposed for inclusion in the next release.
  
  # [Pull request](#Glossary "go to top of document")[§](#Pull_request "direct link")
  
  A feature of [GitHub](https://github.com) and other git hosts like [GitLab](https://gitlab.com) that allows you to make patches to be easily applied using the GitHub web user interface. It means you request someone to do a git pull from your [repository](#Repository) to hers. PR is its usual acronym.
  
  # [priming](#Glossary "go to top of document")[§](#priming "direct link")
  
  Priming (sometimes called [partial function application](https://en.wikipedia.org/wiki/Partial_application) in other programming languages) is the act of creating a new function by providing some but not all of the arguments to an existing function. For example, to create a function that takes one argument and adds 42 to it, you could prime the addition operator with `42` as a single argument: `* + 42`. See [Whatever-priming](/type/Whatever) and [assuming](/type/Code#method_assuming).
  
  # [property](#Glossary "go to top of document")[§](#property "direct link")
  
  In this context, it either refers to an [object property](/language/objects#index-entry-Property-property), which is the value of an instance variable, or a [Unicode property](/language/regexes#Unicode_properties) which are codepoint features that allow programs to identify what kind of entity they represent, that is, if they are a letter, or a number, or something completely different like a control character.
  
  # [pugs](#Glossary "go to top of document")[§](#pugs "direct link")
  
  [pugs](https://en.wikipedia.org/wiki/Pugs) was one of the first interpreters/compilers written for Raku. It was written in Haskell by Audrey Tang.
  
  # [QAST](#Glossary "go to top of document")[§](#QAST "direct link")
  
  Successor to [PAST](#PAST) ('Q' being the next letter after 'P').
  
  # [Rakudo](#Glossary "go to top of document")[§](#Rakudo "direct link")
  
  Rakudo is the name of a Raku implementation that runs on [MoarVM](#MoarVM) and the JVM. It is an abbreviation of `Rakuda-do`, which, when translated from Japanese, means "The Way of the Camel". Also, in Japanese, "Rakudo" means "Paradise."
  
  # [Reify](#Glossary "go to top of document")[§](#Reify "direct link")
  
  In the English language, [reify means](https://www.dictionary.com/browse/reify) "to convert into or regard as a concrete thing." Its meaning in Raku is very similar, in that conceptual things, like "elements of an infinite list", get *reified* when you try to operate on some of them. In general, reification means turning a potential element (be it an element in a lazy list that has not been computed yet or an element in a container that has not been extracted) into its actual value.
  
  # [Repository](#Glossary "go to top of document")[§](#Repository "direct link")
  
  A filesystem under control of a source control management application, usually git, that holds the sources for a project, library or application. This file, for instance, is in [a GitHub repository](https://github.com/Raku/doc). Repositories store not only files, but also history of changes and can be used by the developing or writing team for interaction through issues or comments to code.
  
  In Raku context, however, a repository is also a short name for *compilation unit repository* and constitutes a system that locates and loads modules, managing their installation and precompilation. They are structured as linked lists, including chain of repositories ending in the default `Compunit::Repository::Installation`.
  
  # [RHS](#Glossary "go to top of document")[§](#RHS "direct link")
  
  Acronym for Right-Hand Side, usually refers to the right-hand side of assignment expressions such as `my $bound := $rhs`.
  
  # [roast](#Glossary "go to top of document")[§](#roast "direct link")
  
  The Raku [specification tests](#Test_suite), which live here: <https://github.com/Raku/roast/>. Originally developed for [pugs](#pugs), it now serves all Raku implementations. Why roast? It's the **r**epository **o**f **a**ll **s**pec **t**ests.
  
  # [Roles](#Glossary "go to top of document")[§](#Roles "direct link")
  
  Roles, mix-ins or traits define interfaces and/or implementation of those interfaces as well as instance variables using them, and are mixed-in when declaring classes that follow that interface. [Abstract classes](#Abstract_class) are particular examples of Roles where the actual implementation is deferred to the class that uses that Role.
  
  Roles are part of Raku's [object system](/language/objects), and are declared using the [role](/language/objects#index-entry-role_declaration-role) keyword and used in class declaration via [does](/routine/does).
  
  # [rvalue](#Glossary "go to top of document")[§](#rvalue "direct link")
  
  A value that can be used on the right-hand side of an assignment. See also [lvalue](#lvalue).
  
  # [SAP](#Glossary "go to top of document")[§](#SAP "direct link")
  
  Stands for "Specification APpendices". The [SAP](https://github.com/Raku/roast/tree/master/APPENDICES) includes optional tests that implementations may choose to follow, but don't necessarily have to.
  
  Can be used as a verb. To *SAP* something is to place it into Specification Appendices.
  
  # [Semilist](#Glossary "go to top of document")[§](#Semilist "direct link")
  
  A semilist is a *semicolon-separated* list like this one: `1;3;5`, and is actually a list of lists, with each component of the semilist being a slice of a particular dimension. `@array[1;3;5]` would be equivalent to `@array[1][3][5]`.
  
  # [Sigil](#Glossary "go to top of document")[§](#Sigil "direct link")
  
  In Perl, the sigil is the first character of a variable name. It must be either $, @, %, or & respectively for a [`Scalar`](/type/Scalar), [`Array`](/type/Array), [`Hash`](/type/Hash), or [`Code`](/type/Code) variable. See also Twigil and role. Also sigiled variables allow short conventions for [variable interpolation](#Variable_interpolation) in a double quoted string, or even postcircumfix expressions starting with such a variable.
  
  # [Sigilless variable](#Glossary "go to top of document")[§](#Sigilless_variable "direct link")
  
  [Sigilless variables](/language/variables#index-entry-\_(sigilless_variables)) are actually aliases to the value it is assigned to them, since they are not containers. Once you assign a sigilless variable (using the escape `\`), its value cannot be changed.
  
  # [Spesh](#Glossary "go to top of document")[§](#Spesh "direct link")
  
  A functionality of the [MoarVM](#MoarVM) platform that uses runtime gathered data to improve commonly used pieces of [bytecode](#bytecode). It is much like a JIT compiler, except that those usually output machine code rather than bytecode.
  
  # [STD](#Glossary "go to top of document")[§](#STD "direct link")
  
  `STD.pm` is the "standard" Raku grammar definition (see <https://github.com/perl6/std/>) that was used to implement Raku. STD.pm is no longer really a "specification" in a proscriptive sense: it's more of a guideline or model for Raku implementations to follow.
  
  # [Stub](#Glossary "go to top of document")[§](#Stub "direct link")
  
  Stubs define name and signature of methods whose implementation is deferred to other classes.
  
  ```raku
  role Canine {
      method bark { ... }          # the ... indicates a stub
  }
  ```
  
  Classes with stubs are [Abstract classes](#Abstract_class).
  
  # [Symbol](#Glossary "go to top of document")[§](#Symbol "direct link")
  
  Fancy alternative way to denote a name. Generally used in the context of [module](/language/modules)s linking, be it in the OS level, or at the Raku [virtual machine](#Virtual_machine) level for modules generated from languages targeting these VMs. The set of imported or exported symbols is called the symbol table.
  
  # [Synopsis](#Glossary "go to top of document")[§](#Synopsis "direct link")
  
  The current human-readable description of the Raku language. Still in development. Much more a community effort than the [Apocalypses](#Apocalypse) and [Exegeses](#Exegesis) were. The current state of the language is reflected by [roast](#roast), its [test suite](#Test_suite), not the synopses where speculative material is not always so flagged or more recent additions have not been documented. This is even more true of material that has not been yet implemented.
  
  # [Syntax analysis](#Glossary "go to top of document")[§](#Syntax_analysis "direct link")
  
  A syntax or syntactic analysis is equivalent to [parsing](https://en.wikipedia.org/wiki/Parsing) a string to generate its [parse tree](#Parse_tree).
  
  # [Test suite](#Glossary "go to top of document")[§](#Test_suite "direct link")
  
  The Raku test suite is [roast](#roast).
  
  # [TheDamian](#Glossary "go to top of document")[§](#TheDamian "direct link")
  
  [IRC](#IRC) screen name for [Damian Conway](#Damian_Conway), writer of the original [Exegeses](#Exegesis).
  
  # [TimToady](#Glossary "go to top of document")[§](#TimToady "direct link")
  
  [IRC](#IRC) screen name for [Larry Wall](#Larry_Wall), creator of Perl. The name comes from the pronunciation of [TIMTOWTDI](#TIMTOWTDI) as a word.
  
  # [token](#Glossary "go to top of document")[§](#token "direct link")
  
  In this context, a [`token`](/syntax/token) is a regex that does not backtrack. In general, [tokens](https://en.wikipedia.org/wiki/Lexical_analysis) are extracted from the source program while [lexing](#Lexing).
  
  # [Thunk](#Glossary "go to top of document")[§](#Thunk "direct link")
  
  A piece of code that isn't immediately executed, but doesn't have an independent scope.
  
  # [Tight and loose precedence](#Glossary "go to top of document")[§](#Tight_and_loose_precedence "direct link")
  
  In this context, tight or tighter refers to [precedence rules](/language/functions#Precedence) and is the opposite of `looser`. Precedence rules for new terms are always expressed in relationship with other terms, so `is tighter` implies that operands with that operator will be grouped before operands with the looser operator. Operators with [tight precedence](/language/operators#Tight_AND_precedence) are grouped with priority to others and are generally tighter than most others; loose [exactly the opposite](/language/traps#Loose_Boolean_operators), so it is always convenient to be aware of the exact precedence of all operators used in an expression.
  
  # [Truthy and Falsy](#Glossary "go to top of document")[§](#Truthy_and_Falsy "direct link")
  
  A value is "truthy" if it evaluates to `True` in Boolean context and "falsy" if it evaluates to `False`.
  
  For example, a non-empty string is considered `True` and an empty string `False`:
  
  ```raku
  say so "";                    # OUTPUT: «False␤»
  say so "non-empty";           # OUTPUT: «True␤»
  
  say "truthy" if "non-empty";  # OUTPUT: «truthy␤»
  
  ```
  
  while [`Numeric`](/type/Numeric)s are considered `True` when non-zero:
  
  ```raku
  say so  0;                    # OUTPUT: «False␤»
  say so  1;                    # OUTPUT: «True␤»
  say so -1;                    # OUTPUT: «True␤»
  
  say "truthy" if -1;           # OUTPUT: «truthy␤»
  say 0 || "falsy";             # OUTPUT: «falsy␤»
  
  ```
  
  # [twine](#Glossary "go to top of document")[§](#twine "direct link")
  
  A data structure used to hold a POD string with embedded formatting codes. For example:
  
  ```raku
  =begin pod
  C<foo>
  =end pod
  say $=pod[0].contents[0].contents.raku;
  
  ```
  
  The output will be:
  
  ```raku
  ["", Pod::FormattingCode.new(type => "C", meta => [], config => {}, contents => ["foo"]),""]
  
  ```
  
  [[1]](#fn1)
  
  # [Type objects](#Glossary "go to top of document")[§](#Type_objects "direct link")
  
  A [type object](/language/classtut#A_word_on_types) is an object that is used to represent a type or a class. Since in object oriented programming everything is an object, classes are objects too, and they inherit from [`Mu`](/type/Mu).
  
  # [Type smiley](#Glossary "go to top of document")[§](#Type_smiley "direct link")
  
  A [type smiley](/language/signatures#Constraining_argument_definiteness) is a suffix a type may have that indicates the definiteness of values that can typecheck against it. This may be `:D` to indicate that only defined values can typecheck (i.e. instances), `:U` to indicate that only undefined values can typecheck (i.e. type objects), or `:_` to indicate that both defined and undefined values can typecheck. These resemble emoticons, thus the name.
  
  # [value](#Glossary "go to top of document")[§](#value "direct link")
  
  A value is what is actually contained in a container such as a variable. Used in expressions such as [lvalue](/language/glossary#lvalue), to indicate that that particular container can be assigned to.
  
  # [UB](#Glossary "go to top of document")[§](#UB "direct link")
  
  Stands for "Undefined Behavior". In other words, it is something that is not explicitly specified by the language specification.
  
  # [Value type](#Glossary "go to top of document")[§](#Value_type "direct link")
  
  A type is known as a **value type** if it is immutable and any instance of that type is interchangeable with any other instance "of the same value"—that is, any instance constructed in the same way. An instance of a value type is often *called* a **value** (but should not be confused with [lvalue](#lvalue)s or [rvalue](#rvalue)s).
  
  For example, numbers are value types, so a number constructed one place in your program with, for instance, the literal `3` can't be changed in any way—it simply *is* 3—and any later use of the literal `3` can safely be pointed at the same place in memory as the first with no ill consequences.
  
  Classes doing the roles [`Numeric`](/type/Numeric) and [`Stringy`](/type/Stringy) are among a few examples of built-in value types.
  
  A value type is created by ensuring that an instance of the value type is immutable (i.e., its attributes cannot be modified after construction) and that its [`WHICH`](/routine/WHICH) method returns the same thing every time an instance with the same value is constructed (and conversely returns a different thing every time an instance with a different value is constructed).
  
  The language is free to optimize based on the assumption that equivalent instances of value types are interchangeable, but you should not depend on any such optimization. For instance, if you want [`clone`](/routine/clone) to return an instance of `self`, or you want instance construction to be [memoized](https://en.wikipedia.org/wiki/Memoization) so that re-construction of a previously-constructed value always returns the same instance, you currently must override this behavior yourself.
  
  (The same would hold true of object finalization, but if your instances need special destruction behavior, you almost certainly do not actually have a value type. Values should be thought of as "timeless" and existing in some ideal form outside of your program's memory, like natural values are.)
  
  # [Variable](#Glossary "go to top of document")[§](#Variable "direct link")
  
  A variable is a name for a [container](/language/containers).
  
  # [Variable interpolation](#Glossary "go to top of document")[§](#Variable_interpolation "direct link")
  
  The value of variables is interpolated into strings by simply inserting that variable into the string:
  
  ```raku
  my $polation="polation";
  say "inter$polation";     # OUTPUT: «interpolation␤»
  ```
  
  This might need curly braces in case it precedes some alphanumeric characters
  
  ```raku
  my $inter="inter";
  say "{$inter}polation"; # OUTPUT: «interpolation␤»
  ```
  
  Interpolation occurs in [string context](/language/contexts#String), so a valid stringification method must exist for the class. More general interpolation can be achieved using the [double q](/language/quoting#Interpolation:_qq) quoting constructs.
  
  # [Virtual machine](#Glossary "go to top of document")[§](#Virtual_machine "direct link")
  
  A virtual machine is the Raku compiler entity that executes the [bytecode](#bytecode). It can optimize the bytecode or generate machine code Just in Time. Examples are [MoarVM](#MoarVM), [Parrot](#Parrot) (who are intended to run Raku) and more generic virtual machines such as JVM and Javascript.
  
  ## [WAT](#Glossary "go to top of document")[§](#WAT "direct link")
  
  The opposite of a [DWIM](#DWIM); counter-intuitive behavior. It is said that to every DWIM there is a corresponding WAT. See also <https://www.destroyallsoftware.com/talks/wat>.
  
  # [whitespace](#Glossary "go to top of document")[§](#whitespace "direct link")
  
  A character or group of blank characters, used to separate words. An example is the space character « ».
  
  # [6model](#Glossary "go to top of document")[§](#6model "direct link")
  
  `6model` is used in the [MoarVM](/language/glossary#MoarVM), and provides primitives used to create an object system. It is described in [this presentation by Jonathan Worthington](https://jnthn.net/papers/2013-yapceu-moarvm.pdf) and implemented [here in MoarVM](https://github.com/MoarVM/MoarVM/tree/master/src/6model).
  
  1 [[↑]](#fnret1) The `twine` is an array with an odd number of elements beginning with a simple string, alternating with formatting code objects and simple strings, and ending with a simple string; the formatting code objects are inter`twine`d with the strings. The strings may be empty (as shown in the example). A twine with no formatting code will contain one simple string.
  