Some revision, also #2725, #2483

Author: JJ

doc/Language/5to6-perlvar.pod6

@@ -577,54 +577,32 @@ therefore, as stated before, the C<$!> variable holds the exception object.
 
 =head2 Variables related to the interpreter state
 
-=item $COMPILING
-
-=item $^C
-
-=item $^D
-
-=item ${^ENCODING}
-
-=item ${^GLOBAL_PHASE}
+=head3 $COMPILING, $^C, $^D, ${^ENCODING}, ${^GLOBAL_PHASE}
 
 Currently no equivalents for either of these variables.
 
-=item $^H
-
-=item %^H
-
-=item ${^OPEN}
+=head3 $^H, %^H, ${^OPEN}
 
 There may or may not be equivalents of these in Perl 6, but they're internal
 and you shouldn't be messing with them in the first place - certainly not if
 your understanding of Perl 6 requires you to read this document...
 
-=item $PERLDB
-
-=item $^P
+=head3 $PERLDB, $^P
 
 The chance of the Perl 6 debugger resembling the Perl 5 debugger is slim
 at best, and at this point there does not seem to be an equivalent of
 this variable.
 
-=item ${^TAINT}
+=head3 ${^TAINT}
 
 S28 claims this variable is "pending". Not currently in Perl 6.
 
-=item ${^UNICODE}
-
-=item ${^UTF8CACHE}
-
-=item ${^UTF8LOCALE}
+=head3 ${^UNICODE}, ${^UTF8CACHE}, ${^UTF8LOCALE}
 
 These Unicode-related variables do not appear to exist in Perl 6, but -
 maybe? - could have analogs in C<$?ENC> somewhere. This, however, is
 totally unconfirmed.
 
-=head2 Deprecated and removed variables
-
-It should go without saying that, as these have been removed from Perl 5
-already, there should be no need to tell you how to use them in Perl 6.
 
 =end pod
 

doc/Language/contexts.pod6

@@ -6,21 +6,24 @@
 
 A context is needed, in many occasions, to interpret the value of a container.
 In Perl 6, we will use context to coerce the value of a container into some type
-or class, or decide what to do with it, as in the case of the sink context.
+or class, or in general decide what to do with it, as in the case of the sink
+context.
 
 =head1 Sink X<|sink context>
 
-I<Sink> is equivalent to C<void> context, that is, a context in which we throw
-(down the sink, as it were) the result of an operation or the return value from
-a block. In general, this context will be invoked in warnings and errors when a
-statement does not know what to do with that value.
+The I<sink> context is equivalent to what in other languages is called C<void>
+context, that is, a context in which we throw (down the sink, as it were) the
+result of an operation or the return value from a block. In general, this
+context will be invoked in warnings and errors when a statement does not know
+what to do with that value.
 
 =begin code
 my $sub = -> $a { return $a² };
 $sub; # OUTPUT: «WARNINGS:␤Useless use of $sub in sink context (line 1)␤»
 =end code
 
-X<|sinking> You can force that sink context on L<Iterator|/type/Iterator>s, by
+X<|sinking>
+You can force that sink context on L<Iterator|/type/Iterator>s, by
 using the L<C<sink-all>|/routine/sink-all> method. L<Proc|/type/Proc>s can also
 be L<sunk via the C<sink> method|/type/Proc#method_sink>, forcing them to raise
 an exception and not returning anything.
@@ -39,17 +42,16 @@ sub foo {
         method sink { say "sink called" }
     }
 }
-foo
-# OUTPUT: sink called
+foo; # OUTPUT: sink called
 =end code
 
 
 =head1 Number X<|number context>
 
-This context, and probably all of them except sink above, are I<conversion> or
-I<interpretation> contexts in the sense that they take an untyped or typed
-variable and duck-type it to whatever is needed to perform the operation. In
-some cases that will imply a conversion (from L<Str|/type/Str> to
+This context, and probably all other contexts except I<sink> above, are
+I<conversion> or I<interpretation> contexts in the sense that they take an
+untyped or typed variable and duck-type it to whatever is needed to perform the
+operation. In some cases that will imply a conversion (from L<Str|/type/Str> to
 L<Numeric|/type/Numeric>, for instance); in other cases simply an interpretation
 (L<IntStr|/type/IntStr> will be interpreted as L<Int|/type/Int> or as
 L<Str|/type/Str>).
@@ -82,7 +84,8 @@ say True+$list; # OUTPUT: «4␤»
 =end code
 
 In the case of I<listy> things, the numeric value will be in general equivalent
-to C<.elems>; in some cases, like L<Thread|/routine/Numeric#(Thread)_method_Numeric> it
+to C<.elems>; in some cases, like
+L<Thread|/routine/Numeric#(Thread)_method_Numeric> it
 will return an unique thread identifier.
 
 =head1 String X<|string context>