Clarifies why you can't know the type of a native.

Closes #1568

Also some reflow

Author: JJ

doc/Language/functions.pod6

@@ -13,10 +13,10 @@ called independently of objects.
 Subroutines default to lexical (C<my>) scoping, and calls to them are
 generally resolved at compile time.
 
-Subroutines can have a L<signature|/type/Signature>, also called I<parameter
-list>, which specifies which, if any, arguments the signature expects. It can
-specify (or leave open) both the number and types of arguments, and the
-return value.
+Subroutines can have a L<signature|/type/Signature>, also called
+I<parameter list>, which specifies which, if any, arguments the
+signature expects. It can specify (or leave open) both the number and
+types of arguments, and the return value.
 
 Introspection on subroutines is provided via L<C<Routine>|/type/Routine>.
 

doc/Language/nativetypes.pod6

@@ -4,17 +4,19 @@
 
 =SUBTITLE Using the types the compiler and hardware make available to you
 
-Perl 6 offers a set of I<native> types with a fixed, and known, representation
-in memory. This page shows which ones exist and how they can be used. Please
-check also the page on L<native numerics|/language/numerics#Native_Numerics> for
-more information on them.
+Perl 6 offers a set of I<native> types with a fixed, and known,
+representation in memory. This page shows which ones exist and how they
+can be used. Please check also the page on L<native
+numerics|/language/numerics#Native_Numerics> for more information on
+them.
 
 X<|int>X<|uint>X<|num>X<|str>
 =head1 Types with native representation
 
-Some simple types in Perl 6 have a I<native> representation, indicating that
-they will use the C language representation provided by the compiler, operating
-system and machine. These are the four native types available:
+Some simple types in Perl 6 have a I<native> representation, indicating
+that they will use the C language representation provided by the
+compiler, operating system and machine. These are the four native types
+available:
 
 =begin table
     int            Equivalent to Int
@@ -28,26 +30,29 @@ L<NativeCall|/language/nativecall> interface (e.g., Perl 6's C<int> can be 8
 bytes but C's C<int> is only 4 bytes). Instead, the types below will have to be
 used instead of the types C<int> or C<num> listed above.
 
-In general, these variables will behave in the same way as regular scalar
-variables, in a behavior that is called
-L<I<auto-boxing>|/language/numerics#Auto-Boxing>; however, there are some
-differences, since what you are actually declaring is how they will be
-represented, not their actual type. The first one is that their type will be
-actually their equivalent type, not their native type.
+In general, these variables will behave in the same way as regular
+scalar variables, in a behavior that is called
+L<I<auto-boxing>|/language/numerics#Auto-Boxing>; however, there are
+some differences, since what you are actually declaring is how they will
+be represented, not their actual type. The first one is that their type
+will be actually their equivalent type, not their native type.
 
     my int $intillo = 3;
     say $intillo.^name; # OUTPUT: «Int␤»
 
-This obviously means that they will smartmatch their equivalent, not their
-native type:
+This obviously means that they will smartmatch their equivalent, not
+their native type:
 
     my str $strillo = "tres";
     say $strillo ~~ str; # OUTPUT: «False␤»
     say $strillo ~~ Str; # OUTPUT: «True␤»
 
-They cannot be bound either. Trying to do C<my num $numillo := 3.5> will raise
-the exception C<Cannot bind to natively typed variable '$variable-name'; use
-assignment instead>.
+This is due to the fact that Natives don't know their types because
+they're just values, without any meta-data.
+
+They cannot be bound either. Trying to do C<my num $numillo := 3.5> will
+raise the exception C<Cannot bind to natively typed variable
+'$variable-name'; use assignment instead>.
 
 X<|int8>X<|int16>X<|int32>X<|int64>X<|uint8>X<|uint16>X<|uint32>X<|uint64>X<|num32>X<|num64>X<|byte>
 =head1 Types with native representation and size