Add stubs for stuff inside the glossary already

Author: lizmat

doc/Language/glossary.pod

@@ -92,7 +92,7 @@ L<junctions|#Junction>.  C<Any> itself derives from L<#Mu>.
 =head1 any()
 
 A function generating a L<junction|#Junction> with "or" semantics (aka,
-L<#True> if any of its values are C<True>.
+L<#True> if any of its values are C<True>.  See also L<any|/routine/any>.
 
 =head1 API
 
@@ -157,9 +157,9 @@ L<class|#Class>:
 
 =head1 Autothreading
 
-Autothreading is what happens if you pass a L<Junction|/type/Junction> to
-a subroutine that expects a parameter of type C<Any> or a subtype thereof
-(such as anything L<Cool|/type/Cool>). The call is then executed for each
+Autothreading is what happens if you pass a L<Junction|#Junction> to
+a subroutine that expects a parameter of type L<#Any> or a subtype thereof
+(such as anything L<#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.
 
@@ -182,6 +182,14 @@ values in the junction are True.
         say 'success';
     }
 
+=head1 Callable
+
+=head1 Camelia
+
+=head1 camelia
+
+=head1 Class
+
 =head1 Colon Pair and Colon List
 
 A colon pair is a shorthand syntax used to create or visually present
@@ -231,18 +239,30 @@ referred to as a "type constraint."
 Note that you can elso differentiate candidates in a
 L<multi-dispatch|#Multi-Dispatch> by using a different constraint:
 
-    multi sub abbreviate(Str $thing where { .chars >= 10 }) {
-        "$thing.substr(0,10)..."
+    multi sub abbreviate(Str $thing where { .chars > 10 }) {
+        "$thing.substr(0,7)..."
     }
     multi sub abbreviate(Str $thing) { $thing }  # no constraint
 
-    say abbreviate("Worthington";    # Worthingto...
+    say abbreviate("Worthington";    # Worthin...
     say abbreviate("Mäsak");         # Mäsak
 
+=head1 Cool
+
+=head1 dalek
+
+=head1 Enum
+
+=head1 Exegesis
+
+=head1 False
+
 =head1 Field
 
 See L<#Attribute>.
 
+=head1 Grammar
+
 =head1 Instance
 
 An I<instance> of a class is also called an I<object> in some other
@@ -271,6 +291,8 @@ C<defined($instance)> is C<True>.
 To put things another way, a class contains the blueprints of methods and
 attributes, and an instance carries it into the real world.
 
+=head1 Interface
+
 =head1 IRC
 
 Internet Relay Chat.  Perl 6 developers and users usually hang out on the
@@ -409,7 +431,7 @@ No Such Thing
 
 =head2 Opt
 
-Short for "optimization", usually in either the context of L<#spesh> or
+Short for "optimization", usually in either the context of L<spesh|#Spesh> or
 L<#JIT>.
 
 =head2 PB
@@ -487,6 +509,12 @@ in Perl 6.  It is what C<self> refers to in a method.
     class A { method show { self } }
     say A.new.show;       # A.new
 
+=head2 JIT
+
+=head1 Junction
+
+=head1 List
+
 =head1 Literal
 
 A I<literal> is a piece of code that directly stands for an (often built-in)
@@ -536,14 +564,24 @@ The C<mainline> is the program text that is not part of any kind of block.
     f();        # in mainline again
 
 You can also have the mainline of any package-like declarator, such as
-C<class>, C<module>, C<grammar>, etc.  These are typically run just after
-the class/module/grammar have been compiled (or when loaded from a
-pre-compiled file).
+L<class|#class>, L<module|#Module>, L<grammar|#Grammar>, etc.  These are
+typically run just after the class/module/grammar have been compiled (or
+when loaded from a pre-compiled file).
 
 =head1 Member
 
 See L<#Attribute>.
 
+=head1 Method
+
+=head1 Module
+
+=head1 Mu
+
+=head1 Multi-Dispatch
+
+=head1 Package
+
 =head1 Parameter
 
 L<Parameter|/type/Parameter> is a class to define parameters to
@@ -558,6 +596,17 @@ you specify when calling a subroutine/method/callable block.
 
 See L<#Attribute>.
 
+=head1 Rakudo
+
+=head1 Role
+
+=head1 rvalue
+
+A value that can be used on the right hand side of an assignment.  See also
+L<#lvalue>.
+
+=head1 Sigil
+
 =head1 Slot
 
 See L<#Attribute>.
@@ -577,10 +626,25 @@ This can also be used to collect all possible named parameters in a call:
     sub allnameds(*%named) { .say for %named.sort }
     allnameds a => 42, :666b, :c<foo>;  # a => 42, b => 666, c => foo
 
+=head1 Spesh
+
+=head1 Stub
+
+=head1 Subroutine
+
+=head1 Synopsis
+
+=head1 TimToady
+
+=head1 True
+
+=head1 Twigil
+
 =head1 Type Object
 
-A I<type object> is an object representing a class, role, package, grammar
-or enum. It is generally accessible with the same name as the type.
+A I<type object> is an object representing a L<class|#Class>, L<role|#Role>,
+L<package|#Package>, L<grammar|#Grammar> or L<enum|#Enum>. It is generally
+accessible with the same name as the type.
 
     class A { };
     say A;              # A is the type object
@@ -603,4 +667,14 @@ languages:
     # perl6 -e 'my Int $a; sub f(Int $x) { $x + 1 }; f($a);'
     Invocant requires an instance, but a type object was passed
 
+=head1 yoleaux
+
+=head1 $
+
+=head1 @
+
+=head1 %
+
+=head1 &
+
 =end pod