Fix signatures, skip some examples testing

Author: Altai-man

doc/Language/containers.pod6

@@ -323,6 +323,6 @@ work with types in Perl 6.
     say $a = 12;    # OUTPUT: «12␤»
     say $a = 'FOO'; # X::TypeCheck::Binding
     say $a = 13;    # X::OutOfRange
-    CATCH { default { say .^name, ': ', .Str; .resume } };
+    CATCH { default { say .^name, ': ', .Str } };
 
 =end pod

doc/Language/exceptions.pod6

@@ -32,7 +32,7 @@ then an L<X::IO::DoesNotExist> exception can be raised:
 
     die X::IO::DoesNotExist.new(:path("foo/bar"), :trying("zombie copy"))
 
-    # RESULT: «!> Failed to find 'foo/bar' while trying to do '.zombie copy'
+    # RESULT: «Failed to find 'foo/bar' while trying to do '.zombie copy'
     #          in block <unit> at my-script.p6:1»
 
 Note how the object has provided the backtrace with information about what

doc/Language/faq.pod6

@@ -236,10 +236,12 @@ $x = Int
 If you want to exclude type objects, you can append the C<:D> type smiley,
 which stands for "definite":
 
+    =begin code :skip-test
     my Int:D $x = 42;
     $x = Int;            # dies with:
                          # Type check failed in assignment to $x;
                          # expected Int:D but got Int
+    =end code
 
 Likewise, C<:U> constrains to undefined values, that is, type objects.
 
@@ -252,12 +254,14 @@ a type or a definite value.
 
 Example of a type constraint:
 
+    =begin code :skip-test
     sub divide-to-int( Int $a, Int $b --> Int ) {
             return ($a / $b).narrow;
     }
 
     divide-to-int(3, 2)
     # Type check failed for return value; expected Int but got Rat
+    =end code
 
 Example of a definite return value:
 
@@ -314,6 +318,7 @@ can also contain arrays directly:
 The big difference is that arrays inside a scalar act as one value in list
 context, whereas arrays will be happily iterated over.
 
+    =begin code :skip-test
     my @a = 1, 2, 3;
     my $s = @a;
 
@@ -325,6 +330,7 @@ context, whereas arrays will be happily iterated over.
 
     my @nested = flat $s, $s;
     say @nested.elems;          # OUTPUT: «2␤»
+    =end code
 
 You can force flattening with C<@( ... )> or by calling the C<.list> method
 on an expression, and item context (not flattening) with C<$( ... )>
@@ -350,8 +356,10 @@ There are several reasons:
 
 You likely tried to mix string interpolation and HTML.
 
+    =begin code :skip-test
     my $foo = "abc";
     say "$foo<html-tag>";
+    =end code
 
 Perl 6 thinks C<$foo> to be a Hash and C«<html-tag>» to be a string literal
 hash key. Use a closure to help it to understand you.

doc/Language/list.pod6

@@ -60,8 +60,9 @@ One of the ways C<@>-sigiled variables act like lists is by always supporting
 L<positional subscripting|/language/subscripts>. Anything bound to a C<@>-sigiled
 value must support the L<Positional|/type/Positional> role which guarantees this:
 
+    =begin code :skip-test
     my @a := 1; # Type check failed in binding; expected Positional but got Int
-
+    =end code
 
 =head1 Reset a List Container
 
@@ -109,7 +110,9 @@ Although the C<Seq> class does provide some positional subscripting, it does
 not provide the full interface of C<Positional>, so an C<@>-sigiled variable
 may B<not> be bound to a C<Seq>.
 
+    =begin code :skip-test
     my @s := (loop { 42.say }); # Error expected Positional but got Seq
+    =end code
 
 This is because the C<Seq> does not keep values around after you have used them.
 This is useful behavior if you have a very long sequence, as you may want to
@@ -179,9 +182,11 @@ The lists we have talked about so far (C<List>, C<Seq> and C<Slip>)
 are all immutable.  This means you cannot remove elements from them,
 or re-bind existing elements:
 
+    =begin code :skip-test
     (1, 2, 3)[0]:delete; # Error Can not remove elements from a List
     (1, 2, 3)[0] := 0;   # Error Cannot use bind operator with this left-hand side
     (1, 2, 3)[0] = 0;    # Error Cannot modify an immutable Int
+    =end code
 
 However, if any of the elements is wrapped in a L<C<Scalar>|/type/Scalar> you
 can still change the value which that C<Scalar> points to:
@@ -281,7 +286,9 @@ of pair forms happens.
 Most C<Positional> types will enforce an integer coercion on each element
 of a slice index, so pairs appearing there will generate an error, anyway:
 
-    (1, 2, 3)[1, 2, :c(3)] # Method 'Int' not found for invocant of class 'Pair'
+    =begin code :skip-test
+    (1, 2, 3)[1, 2, :c(3)] # OUTPUT: «Method 'Int' not found for invocant of class 'Pair'␤»
+    =end code
 
 ...however this is entirely up to the type – if it defines an order
 for pairs, it could consider C<:c(3)> a valid index.
@@ -339,6 +346,7 @@ is of type C<Array[Int]> and one can create one with C<Array[Int].new>.  If
 you intend to use an C<@>-sigiled variable only for this purpose, you may
 change its type by specifying the type of the elements when declaring it:
 
+    =begin code :skip-test
     my Int @a = 1, 2, 3;              # An Array that contains only Ints
     my @b := Array[Int].new(1, 2, 3); # Same thing, but the variable is not typed
     say @b eqv @a;                    # says True.
@@ -350,15 +358,18 @@ change its type by specifying the type of the elements when declaring it:
 
     @a[0] = 42;                       # fine
     @a[0] = "foo";                    # error: Type check failed in assignment
+    =end code
 
 In the above example we bound a typed Array object to a C<@>-sigil variable for
 which no type had been specified.  The other way around does not work – you may
 not bind an Array that has the wrong type to a typed C<@>-sigiled variable:
 
+    =begin code :skip-test
     my @a := Array[Int].new(1, 2, 3);     # fine
     @a := Array[Str].new("a", "b");       # fine, can be re-bound
     my Int @b := Array[Int].new(1, 2, 3); # fine
     @b := Array.new(1, 2, 3);             # error: Type check failed in binding
+    =end code
 
 When working with typed arrays, it is important to remember that they are
 nominally typed. This means the declared type of an array is what matters.

doc/Language/operators.pod6

@@ -1209,11 +1209,13 @@ Instead of a role, you can provide an instantiated object. In this case,
 the operator will create a role for you automatically. The role will contain
 a single method named the same as C<$obj.^name> and that returns C<$obj>:
 
+    =begin code :skip-test
     say 42 but 'forty two'; # OUTPUT: «forty two␤»
 
     my $s = 12 but class Warbles { method hi { 'hello' } }.new;
     say $s.Warbles.hi;    # OUTPUT: «hello␤»
     say $s + 42;          # OUTPUT: «54␤»
+    =end code
 
 If methods of the same name are present already, the last mixed in role takes
 precedence. A list of methods can be provided in parentheses separated by

doc/Language/quoting.pod6

@@ -173,11 +173,13 @@ Interpolation of undefined values will raise a control exception that can be
 caught in the current block with
 L<CONTROL|https://docs.perl6.org/syntax/CONTROL>.
 
+    =begin code :skip-test
     sub niler {Nil};
     my Str $a = niler;
     say("$a.html", "sometext");
     say "alive"; # this line is dead code
     CONTROL { .die };
+    =end code
 
 =head2 Word quoting: qw
 X<|qw word quote>

doc/Language/regexes.pod6

@@ -44,9 +44,9 @@ Alphanumeric characters and the underscore C<_> are matched literally. All
 other characters must either be escaped with a backslash (for example, C<\:>
 to match a colon), or be within quotes:
 
-    / 'two words' /     # matches 'two words' including the blank
-    / "a:b"       /     # matches 'a:b' including the colon
-    / '#' /             # matches a hash character
+    / 'two words' /;     # matches 'two words' including the blank
+    / "a:b"       /;     # matches 'a:b' including the colon
+    / '#' /;             # matches a hash character
 
 Strings are searched left to right, so it's enough if only
 part of the string matches the regex:

doc/Language/subscripts.pod6

@@ -115,8 +115,10 @@ invocant as a list of one element. (But there's no such fallback for
 associative subscripts, so they throw a run-time error when applied to an
 object that does not implement support for them.)
 
+    =begin code :skip-test
     say 42[0];    # OUTPUT: «42␤»
     say 42<foo>;  # ERROR: postcircumfix { } not defined for type Int
+    =end code
 
 =head1 Nonexistent elements
 
@@ -588,6 +590,7 @@ See also the L<keys> routine.
 Return the bare value of the element (rather than potentially returning a
 mutable value container), and silently skip nonexistent elements:
 
+    =begin code :skip-test
     my @tens = 0, 10, 20, 30;
     dd @tens[1]:v;        # OUTPUT: «10␤»
     dd @tens[0, 4, 2]:v;  # OUTPUT: «(0, 20)␤»
@@ -597,6 +600,7 @@ mutable value container), and silently skip nonexistent elements:
     my %month = Jan => 1, Feb => 2, Mar => 3;
     dd %month<Feb>:v;          # OUTPUT: «2␤»
     dd %month<Jan Foo Mar>:v;  # OUTPUT: «(1, 3)␤»
+    =end code
 
 If you I<don't> want to skip nonexistent elements, use the negated form:
 
@@ -645,6 +649,7 @@ subscripting interface.
 Imagine a HTTP::Header type which, despite being a custom class with special
 behavior, can be indexed like a hash:
 
+    =begin code :skip-test
     my $request = HTTP::Request.new(GET => "perl6.org");
     say $request.header.WHAT;  # OUTPUT: «(HTTP::Header)␤»
 
@@ -655,6 +660,7 @@ behavior, can be indexed like a hash:
     say $request.header<Accept-Language>.perl;  # OUTPUT: «["en", "fr"]␤»
 
     my $rawheader = $request.header.Str;  # stringify according to HTTP spec
+    =end code
 
 The simplest way to implement this class, would be to give it an attribute of
 type L<Hash>, and delegate all subscripting and iterating related functionality

doc/Type/Callable.pod6

@@ -77,11 +77,13 @@ value of the right function will be L<slipped|/type/Slip> into the left function
     # or to:
     say f g 2;
 
+    =begin code
     sub f($a, $b, $c) { [~] $c, $b, $a }
     sub g($str){ $str.comb }
     my &composed = &f ∘ &g;
     say composed 'abc'; # OUTPUT: «cba␤»
     # equivalent to:
     say f |g 'abc';
+    =end code
 
 =end pod

doc/Type/IO/Socket/Async.pod6

@@ -96,19 +96,23 @@ listener should be C<close>d.
 
 For example, when using C<tap>:
 
+    =begin code :skip-test
     my $listener = IO::Socket::Async.listen('127.0.0.1', 8080);
     my $tap = $listener.tap({ ... });
 
     # When you want to close the listener
     $tap.close;
+    =end code
 
 Or when using C<whenever>:
 
+    =begin code :skip-test
     my $listener = IO::Socket::Async.listen('127.0.0.1', 5000);
     my $big-finish = Promise.new;
     my $tap = do whenever $listener -> $conn { ... }
     await $big-finish;
     $tap.close;
+    =end code
 
 =head2 method udp