doc new behaviour of Nil and add Nilness of subclasses of Nil

Author: gfldex

doc/Type/Nil.pod6

@@ -7,19 +7,18 @@
     class Nil is Cool { }
 
 The value C<Nil> may be used to fill a spot where a value would normally
-go, and in so doing, explicitly indicate that no value is present.  It
+go, and in so doing, explicitly indicate that no value is present. It
 may also used as a cheaper and less explosive alternative to a
 L<C<Failure>|/type/Failure>.
 
 The class C<Nil> is the same exact thing as its only possible value, C<Nil>.
 
     say Nil === Nil.new         #-> True
 
-Along with C<Failure>, C<Nil> is one of the two types which may
-always be returned from a routine even when the routine specifies a
-particular return type.  It may also be returned regardless of the
-definedness of the return type, however, C<Nil> is considered undefined
-for all other purposes.
+Along with C<Failure>, C<Nil> and its sub classes may always be returned from a
+routine even when the routine specifies a particular return type. It may also
+be returned regardless of the definedness of the return type, however, C<Nil>
+is considered undefined for all other purposes.
 
     sub a( --> Int:D ) { return Nil }
     a().say;                    #-> Nil
@@ -48,21 +47,16 @@ C<Nil>.
     say (Nil)[100];                  #-> Nil
     say (Nil){100};                  #-> Nil
 
-When assigned, C<Nil> will revert a container to its default value, if no such
-default is provided Perl 6 assumes C<Any>. This includes initializers on
-defined constrained types. Returning C<Nil> from a routine will break the
-definedness constraint. Subsequent assignments to another definedness
-constraint container, including L<Signature|/type/Signature>s, will properly
-fail.
+When assigned, C<Nil> and any subclass of C<Nil> will revert a container to its
+default value, if no such default is provided Perl 6 assumes C<Any>. Assigning
+to a defined constrained container will produce a L<Failure|/type/Failure>.
 
     my Int $x = 42;
     $x = Nil;
     $x.say;                     #-> (Int)
 
-    sub f(-->Int:D){Nil};
-    my Int:D $i = f;
-    say $i.defined;
-    # OUTPUT«False␤»
+    sub f( -->Int:D ){ Nil }; # this definedness constraint is ignored
+    my Int:D $i = f; # this definedness contraint is not ignored
 
 Because an untyped variable is type C<Any>, assigning a C<Nil> to one
 will result in an L<(Any)|/type/Any> type object.

doc/Type/Signature.pod6

@@ -196,10 +196,9 @@ the signature after the argument name.
 The token C<-->> followed by a type will force a type check on successful
 execution of a routine. The return type arrow has to be placed at the end of
 the parameter list. The keyword C<returns> following a signature declaration
-has the same function. C<Nil> is considered as being defined for the type
-check. Type objects and thus undefined values will pass the test unless the
-type smiley C<:D> is used.
-
+has the same function. C<Nil> and its subclasses are ignored in return
+constraints. This allowes L<Failure|/type/Failure> to be returned and passed on
+down the call chain.
 
     sub foo(--> Int) { my Int $i; $i };
     sub foo(--> Int:D) { 1 }