Merge pull request #194 from dha/master

Indentations for better web rendering

Author: zoffixznet

doc/Language/5to6-perlfunc.pod

@@ -56,32 +56,32 @@ traditional way (although you can) to do a filetest. You can simply append
 C<.IO> to the filename. For instance, here is how to check if a file is
 readable using smart match:
 
-C<'/path/to/file'.IO ~~ :r>
+    C<'/path/to/file'.IO ~~ :r>
 
 You can, of course, use an already opened filehandle. Here, using the file
 handle C<$fh>, is an example, using the method syntax for the file test:
 
-C<$fh.r>
+    C<$fh.r>
 
 Most of the former filetests have colon equivalents for use with smart match:
 
-:e Exists
-:d Directory
-:f File
-:l Symbolic link
-:r Readable
-:w Writable
-:x Executable
-:s Size
-:z Zero size
+    :e Exists
+    :d Directory
+    :f File
+    :l Symbolic link
+    :r Readable
+    :w Writable
+    :x Executable
+    :s Size
+    :z Zero size
 
 All of these tests can be used as methods (without the colon).
 
 Three tests, however, I<only> have method equivalents:
 
-C<-M $fh> => C<$fh.modified>
-C<-A $fh> => C<$fh.accessed>
-C<-C $fh> => C<$fh.changed>
+    C<-M $fh> => C<$fh.modified>
+    C<-A $fh> => C<$fh.accessed>
+    C<-C $fh> => C<$fh.changed>
 
 The remaining filetests in Perl 5 do not appear to be implemented
 in Perl 6.
@@ -130,8 +130,8 @@ find a true analog.
 Available as a function as well as being able to be used as a method.
 For instance, these are equivalent:
 
-C<atan2(100)>
-C<100.atan2>
+    C<atan2(100)>
+    C<100.atan2>
 
 =head2 bind
 
@@ -229,8 +229,8 @@ Similar to the Perl 5 version, coerces the target to an integer, and uses that
 as a Unicode code point to return the relevant character. Can be used as a
 function and a method:
 
-C<chr(65); # "A">
-C<65.chr;  # "A">
+    C<chr(65); # "A">
+    C<65.chr;  # "A">
 
 =head2 chroot
 
@@ -389,8 +389,8 @@ shell($command);>
 
 In Perl 6, this is not a function, but an adverb:
 
-C<%hash{$key}:exists;>
-C<@array[$i]:exists;>
+    C<%hash{$key}:exists;>
+    C<@array[$i]:exists;>
 
 =head2 exit
 
@@ -879,9 +879,9 @@ deals with newlines. Details at L<http://doc.perl6.org/routine/open>.
 
 Not a builtin function in Perl 6. You would use the IO::Path class:
 
-C<my $dir = IO::Path.new("directory")>
+    C<my $dir = IO::Path.new("directory")>
 
-C<my $dir = "directory".IO; # Same, but probably more direct>
+    C<my $dir = "directory".IO; # Same, but probably more direct>
 
 =head2 ord
 
@@ -1013,9 +1013,9 @@ L<append method|/type/Array#method_append>.
 
 These survive the transition to Perl 6. Some notes:
 
-C<q/.../> is still equivalent to using single quotes.
-C<qq/.../> is still equivalent to using double quotes.
-C<qw/.../> is more commonly rendered as C<< <...> >> in Perl 6.
+    C<q/.../> is still equivalent to using single quotes.
+    C<qq/.../> is still equivalent to using double quotes.
+    C<qw/.../> is more commonly rendered as C<< <...> >> in Perl 6.
 
 There are some added quoting constructs and equivalents, as explained at
 L<http://doc.perl6.org/language/quoting>.
@@ -1364,41 +1364,41 @@ also now works as a method: C<"a;b;c".split(';')>
 
 Works as in Perl 5. The formats currently available are:
 
-%   a literal percent sign
-c   a character with the given codepoint
-s   a string
-d   a signed integer, in decimal
-u   an unsigned integer, in decimal
-o   an unsigned integer, in octal
-x   an unsigned integer, in hexadecimal
-e   a floating-point number, in scientific notation
-f   a floating-point number, in fixed decimal notation
-g   a floating-point number, in %e or %f notation
-X   like x, but using uppercase letters
-E   like e, but using an uppercase "E"
-G   like g, but with an uppercase "E" (if applicable)
+    %   a literal percent sign
+    c   a character with the given codepoint
+    s   a string
+    d   a signed integer, in decimal
+    u   an unsigned integer, in decimal
+    o   an unsigned integer, in octal
+    x   an unsigned integer, in hexadecimal
+    e   a floating-point number, in scientific notation
+    f   a floating-point number, in fixed decimal notation
+    g   a floating-point number, in %e or %f notation
+    X   like x, but using uppercase letters
+    E   like e, but using an uppercase "E"
+    G   like g, but with an uppercase "E" (if applicable)
 
 Compatibility:
 
-i   a synonym for %d
-D   a synonym for %ld
-U   a synonym for %lu
-O   a synonym for %lo
-F   a synonym for %f
+    i   a synonym for %d
+    D   a synonym for %ld
+    U   a synonym for %lu
+    O   a synonym for %lo
+    F   a synonym for %f
 
 Perl 5 (non-)compatibility:
 
-n   produces a runtime exception
-p   produces a runtime exception
+    n   produces a runtime exception
+    p   produces a runtime exception
 
 There are modifiers for integers, but they're mainly no-ops, as the
 semantics aren't settled:
 
-h  interpret integer as native "short" (typically int16)
-l  interpret integer as native "long" (typically int32 or int64)
-ll interpret integer as native "long long" (typically int64)
-L  interpret integer as native "long long" (typically uint64)
-q  interpret integer as native "quads" (typically int64 or larger)
+    h  interpret integer as native "short" (typically int16)
+    l  interpret integer as native "long" (typically int32 or int64)
+    ll interpret integer as native "long long" (typically int64)
+    L  interpret integer as native "long long" (typically uint64)
+    q  interpret integer as native "quads" (typically int64 or larger)
 
 =head2 sqrt
 

doc/Language/5to6-perlop.pod

@@ -168,10 +168,10 @@ In list context, C<..> operates as the range operator and should not
 need to be changed. That said, there are exclusionary range operators
 that may be useful. These are:
 
-infix  ..^  Excludes endpoint. C<1..^5; # 1 2 3 4 >
-infix  ^..  Excludes startpoint. C<1^..5; # 2 3 4 5>
-infix  ^..^ Excludes both start- and endpoint. C<1^..^5; # 2 3 4>
-prefix ^    From 0, excludes endpoint. C<^5; # 0 1 2 3 4>
+    infix  ..^  Excludes endpoint. C<1..^5; # 1 2 3 4 >
+    infix  ^..  Excludes startpoint. C<1^..5; # 2 3 4 5>
+    infix  ^..^ Excludes both start- and endpoint. C<1^..^5; # 2 3 4>
+    prefix ^    From 0, excludes endpoint. C<^5; # 0 1 2 3 4>
 
 In scalar context, C<..> and C<...> work as flip-flop operators in Perl
 5, but are little-known, and probably even less used. Those operations

doc/Language/5to6-perlvar.pod

@@ -211,8 +211,8 @@ This is somewhat unclear. It probably depends on what you mean by "the name of
 the operating system" as S28 has three different suggestions, all of which
 give different answers. On my OS X machine at this time...
 
-C<$*KERNEL> gives "darwin (14.3.0)"
-C<$*DISTRO> gives "macosx (10.10.3)"
+    C<$*KERNEL> gives "darwin (14.3.0)"
+    C<$*DISTRO> gives "macosx (10.10.3)"
 
 Using C<.version> on either of those will give you just the version
 number. C<.name> gives the kernel or distro name. Those objects contain