Rephrase slightly Slurpy (function) Conventions.

Links to types whenever possible.

Author: fluca1978

doc/Language/functions.pod6

@@ -344,33 +344,34 @@ many modules, will follow.
 
 =head2 Slurpy Conventions
 
-Perhaps the most important of these is the way slurpy list arguments are
+Perhaps the most important one of these conventions is the way slurpy list arguments are
 handled.  Most of the time, functions will not automatically flatten
-slurpy lists.  The rare exceptions are those functions that don't have a
-reasonable behavior on lists of lists; for example, L<chrs|/routine/chrs>,
-or where there is a conflict with an established idiom, like L<pop|/routine/pop>
-being the inverse of L<push|/routine/push>.
+slurpy lists.
+The rare exceptions are those functions that don't have a
+reasonable behavior on lists of lists (e.g., L<chrs|/routine/chrs>)
+or where there is a conflict with an established idiom (e.g., L<pop|/routine/pop>
+being the inverse of L<push|/routine/push>).
 
-If you wish to match this look and feel, any Iterable argument must
-be broken out element-by-element using a **@ slurpy, with two nuances:
+If you wish to match this look and feel, any L<Iterable|/type/Iterable> argument must
+be broken out element-by-element using a C<**@> slurpy, with two nuances:
 
-=item An Iterable inside a L<Scalar container|/language/containers#Scalar_containers> doesn't count.
+=item An L<Iterable|/type/Iterable> inside a L<Scalar container|/language/containers#Scalar_containers> doesn't count.
 
-=item Lists created with a L<C<,>|/routine/,> at the top level only count as one Iterable.
+=item L<List|/type/List>s created with a L<C<,>|/routine/,> at the top level only count as one L<Iterable|/type/Iterable>.
 
 This can be achieved by using a slurpy with a C<+> or C<+@> instead of C<**>:
 
     sub grab(+@a) { "grab $_".say for @a }
 
-...which is shorthand for something very close to:
+which is shorthand for something very close to:
 
     multi sub grab(**@a) { "grab $_".say for @a }
     multi sub grab(\a) {
         a ~~ Iterable and a.VAR !~~ Scalar ?? nextwith(|a) !! nextwith(a,)
     }
 
-This results in the following behavior, which is known as the "single
-argument rule" and is important to understand when invoking slurpy functions:
+This results in the following behavior, which is known as the
+I<"single argument rule"> and is important to understand when invoking slurpy functions:
 
 =for code :preamble<sub grab(+@a) {};>
 grab(1, 2);      # OUTPUT: «grab 1␤grab 2␤»
@@ -388,7 +389,7 @@ grab(flat (1, 2));           # OUTPUT: «grab 1␤grab 2␤»
 grab(flat $(1, 2));          # OUTPUT: «grab 1␤grab 2␤»
 
 It's worth noting that mixing binding and sigilless variables
-in these cases requires a bit of finesse, because there is no Scalar
+in these cases requires a bit of finesse, because there is no L<Scalar|/type/Scalar>
 intermediary used during binding.
 
 =for code :preamble<sub grab(+@a) {};>