Make examples compile

Author: Altai-man

doc/Type/Callable.pod6

@@ -14,7 +14,7 @@ of such a container is C<Callable>. A signature object can be used to
 force a check against the signature of the Callable to be stored into the
 container.
 
-    my &a = {};
+    my &a = {;}; # Empty block needs a semicolon
     my &b = -> {};
     my &c = sub () {};
     sub foo() {};

doc/Type/Failure.pod6

@@ -30,47 +30,43 @@ Defined as:
 
     method handled(Failure:D:) returns Bool:D
 
-Usage:
-
-    FAILURE.handled
-
 Returns C<True> for handled failures, C<False> otherwise.
 
+    sub f() { fail }; my $v = f; say $v.handled; # False
+
 =head2 method exception
 
 Defined as:
 
     method exception(Failure:D:) returns Exception
 
-Usage:
-
-    FAILURE.exception
-
 Returns the L<Exception> object that the failure wraps.
 
+    sub f() { fail }; my $v = f; $v.Exception;
+    CATCH { default { put .^name, ': ', .Str } };
+    # OUTPUT: «X::AdHoc: Failed␤»
+
 =head2 method Bool
 
 Defined as:
 
     multi method Bool(Failure:D:) returns Bool:D
 
-Usage:
-
-    FAILURE.Bool
-
 Returns C<False>, and marks the failure as handled.
 
+    sub f() { fail }; my $v = f; say $v.handled; $v.Bool; say $v.handled;
+    # False
+    # True
+
 =head2 method defined
 
 Defined as:
 
     multi method defined(Failure:D:) returns Bool:D
 
-Usage:
-
-    FAILURE.defined
-
 Returns C<False> (failures are officially undefined), and marks
 the failure as handled.
 
+    sub f() { fail }; my $v = f; say $v.defined; # False
+
 =end pod

doc/Type/Nil.pod6

@@ -14,41 +14,41 @@ so smartmatching C<Nil> will also match C<Failure>.)
 
 The class C<Nil> is the same exact thing as its only possible value, C<Nil>.
 
-    say Nil === Nil.new         #-> True
+    say Nil === Nil.new         # True
 
 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
+    a().say;                    # Nil
 
 C<Nil> is what is returned from empty routines or clauses, or routines
 that use a bare C<return> statement.
 
-    sub a { }; a().say;         #-> Nil
-    sub b { return }; b().say;  #-> Nil
-    say (if 1 { });             #-> Nil
-    { ; }().say;                #-> Nil
-    say EVAL "";                #-> Nil
+    sub a { }; a().say;         # Nil
+    sub b { return }; b().say;  # Nil
+    say (if 1 { });             # Nil
+    { ; }().say;                # Nil
+    say EVAL "";                # Nil
 
 In a list, C<Nil> takes the space of one value.  Iterating a C<Nil>
 behaves like iteration of any non-iterable value, producing a sequence
 of one C<Nil>. (When you need the other meaning, the special value
 C<Empty|/type/Slip#Empty> is available to take no spaces when inserted into
 list, and to return no values when iterated.)
 
-    (1, Nil, 3).elems.say;      #-> 3
-    (for Nil { $_ }).perl.say;  #-> (Nil,)
+    (1, Nil, 3).elems.say;      # 3
+    (for Nil { $_ }).perl.say;  # (Nil,)
 
 Any method call on C<Nil> other than those specifically listed below,
 and consequently, any subscripting operation, will succeed and return
 C<Nil>.
 
-    say Nil.ITotallyJustMadeThisUp;  #-> Nil
-    say (Nil)[100];                  #-> Nil
-    say (Nil){100};                  #-> Nil
+    say Nil.ITotallyJustMadeThisUp;  # Nil
+    say (Nil)[100];                  # Nil
+    say (Nil){100};                  # Nil
 
 When assigned to a container, the C<Nil> value (but not any subclass of
 C<Nil>) will attempt to revert the container to its default value; if no
@@ -60,37 +60,53 @@ type unless it happens to be a parent class of C<Failure>.)
 
     my Int $x = 42;
     $x = Nil;
-    $x.say;                     #-> (Int)
+    $x.say;                     # (Int)
 
     sub f( --> Int:D ){ Nil }; # this definedness constraint is ignored
     my Int:D $i = f; # this definedness contraint is not ignored, so throws
+    CATCH { default { put .^name, ': ', .Str } };
+    # OUTPUT: «X::TypeCheck::Assignment: Type check failed in assignment to $y; expected Int but got Any (Any)»
 
     sub g( --> Int:D ){ fail "oops" }; # this definedness constraint is ignored
-    my Any:D $i = g; # failure object matches Any:D, so is assigned
-    my Int:D $j = g; # failure object doesn't match Int:D, so throws
+    my Any:D $h = g; # failure object matches Any:D, so is assigned
+
+but
+
+=for code :skip-test
+my Int:D $j = g;
+# It will throw both exceptions:
+# Earlier failure:
+#  oops
+#   in sub g at <unknown file> line 1
+#   in block <unit> at <unknown file> line 1
+#
+# Final error:
+#  Type check failed in assignment to $j; expected Int:D but got Failure (Failure.new(exception...)
+#   in block <unit> at <unknown file> line 1
 
 Because an untyped variable is type C<Any>, assigning a C<Nil> to one
 will result in an L<(Any)|/type/Any> type object.
 
     my $x = Nil;
-    $x.say;          #-> (Any)
-    my Int $y = $x;  # error:  Type check failed in assignment to '$y';
-                     # expected 'Int' but got 'Any'
+    $x.say;          # (Any)
+    my Int $y = $x;  # error
+    CATCH { default { put .^name, ': ', .Str } };
+    # OUTPUT: «X::TypeCheck::Assignment: Type check failed in assignment to $y; expected Int but got Any (Any)␤»
 
 If you are looking for a variable which transforms objects into type objects
 when said variable appears on the RHS, you can type the container as C<Nil>.
 
     my Nil $x;
     my Str $s = $x;
-    $s.say;          #-> (Str)
+    $s.say;          # (Str)
 
 There is an important exception to this transforms-into-type-object rule:
 assigning C<Nil> to a variable which has a default will restore that default.
 
     my Int $x is default(42) = -1;
     my $y = 1;
     for $x, $y -> $val is rw { $val = Nil unless $val > 0 }
-    $x.say;          #-> 42
+    $x.say;          # 42
 
 =head1 Methods
 

doc/Type/Parameter.pod6

@@ -100,7 +100,9 @@ Returns C<True> for raw parameters.
         raw = 5;
     }
     f(my $x);   # works
-    f(42);      # dies in the assignment
+    f(42);      # dies
+    CATCH { default { put .^name, ': ', .Str } };
+    # OUTPUT: «X::Assignment::RO: Cannot modify an immutable Int␤»
 
 Raw parameters bind either a variable or a value passed to it, with
 no decontainerization taking place.  That means that if a variable was passed
@@ -171,19 +173,21 @@ The type used may change from call to call.  Once they are defined,
 type captures can be used wherever you would use a type, even later
 in same the signature:
 
-    sub c(::T $x, T $y, $z) { my T $zz = $z };
-    c(4, 5, 6);          # OK
-    c(4, 5, "six");      # Fails when assigning to $zz, wants Int not Str
-    c("four", 5, "six"); # Fails when binding $y, wants Str, not Int
+=for code :skip-test
+sub c(::T $x, T $y, $z) { my T $zz = $z };
+c(4, 5, 6);          # OK
+c(4, 5, "six");      # Fails when assigning to $zz, wants Int not Str
+c("four", 5, "six"); # Fails when binding $y, wants Str, not Int
 
 Type captures may be used at the same time as
 L<type constraints|/type/Signature#Type_Constraints>.
 
-    sub d(::T Numeric $x, T $y);
-    d(4, 5);            # OK
-    d(4e0, 5e0);        # OK
-    d(4e0, 5);          # Fails when binding $y
-    d("four", "five");  # Fails when binding $x
+=for code :skip-test
+sub d(::T Numeric $x, T $y);
+d(4, 5);            # OK
+d(4e0, 5e0);        # OK
+d(4e0, 5);          # Fails when binding $y
+d("four", "five");  # Fails when binding $x
 
 =head2 method sub_signature
 

doc/Type/Range.pod6

@@ -4,7 +4,8 @@
 
 =SUBTITLE Interval of ordered values
 
-    class Range is Iterable does Positional {}
+=for code :skip-test
+class Range is Iterable does Positional {}
 
 Ranges serve two main purposes: to generate lists of consecutive
 numbers or strings, and to act as a matcher to check if a number
@@ -14,15 +15,16 @@ Ranges are constructed using one of the four possible range operators,
 which consist of two dots, and optionally a caret which indicates that
 the endpoint marked with it is excluded from the range.
 
-    1 .. 5  # 1 <= $x <= 5
-    1^.. 5  # 1 <  $x <= 5
-    1 ..^5  # 1 <= $x <  5
-    1^..^5  # 1 <  $x <  5
+    1 .. 5;  # 1 <= $x <= 5
+    1^.. 5;  # 1 <  $x <= 5
+    1 ..^5;  # 1 <= $x <  5
+    1^..^5;  # 1 <  $x <  5
 
 The caret is also a prefix operator for constructing numeric ranges
 starting from zero:
 
-    ^$x     # same as 0 ..^ $x.Numeric
+    my $x = 10;
+    say ^$x;     # same as 0 ..^ $x.Numeric
 
 Iterating a range (or calling the C<list> method) uses the same semantics as
 the C<++> prefix and postfix operators, i.e., it calls the C<succ> method on
@@ -31,20 +33,21 @@ the start point, and then the generated elements.
 Ranges always go from small to larger elements; if the start point is bigger
 than the end point, the range is considered empty.
 
-    for 1..5 { .say }       # five iterations
-    ('a' ^..^ 'f').list     # 'b', 'c', 'd', 'e'
-    5 ~~ ^5;                # False
-    4.5 ~~ 0..^5            # True
-    (1.1..5).list;          # (1.1, 2.1, 3.1, 4.1)
+    for 1..5 { .say };       # five iterations
+    ('a' ^..^ 'f').list;     # 'b', 'c', 'd', 'e'
+    5 ~~ ^5;                 # False
+    4.5 ~~ 0..^5;            # True
+    (1.1..5).list;           # (1.1, 2.1, 3.1, 4.1)
 
 Use the C<...> sequence operator to produce lists of elements that
 go from larger to smaller values, or to use offsets other than
 increment-by-1.
 
 Use C<Inf> or C<*> (Whatever) to indicate an end point to be open-ended.
 
-    for 1..* { .say }       # start from 1, continue until stopped
-    for 1..Inf { .say }     # the same
+=for code :skip-test
+for 1..* { .say };       # start from 1, continue until stopped
+for 1..Inf { .say };     # the same
 
 =head2 Ranges in subscripts
 
@@ -138,7 +141,9 @@ L<excludes-max> are C<True> in which case a L<Failure|/type/Failure> is returned
     say $r3.is-int, ', ', $r4.is-int;                 # False, False
     say $r3.excludes-max, ', ', $r4.excludes-max;     # False, True
     say $r3.minmax;                                   # (1.1 5.2)
-    say $r4.minmax;                                   # Cannot return minmax on Range with excluded ends
+    say $r4.minmax;
+    CATCH { default { put .^name, ': ', .Str } };
+    # OUTPUT: «X::AdHoc: Cannot return minmax on Range with excluded ends␤»
 
 =head2 method elems
 
@@ -162,16 +167,16 @@ Generates the list of elements that the range represents.
 
 =head2 method pick
 
-    method pick(Range:D:        ) returns Any:D
-    method pick(Range:D: $number) returns Seq:D
+    multi method pick(Range:D:        ) returns Any:D
+    multi method pick(Range:D: $number) returns Seq:D
 
 Performs the same function as C<Range.list.pick>, but attempts to optimize
 by not actually generating the list if it is not necessary.
 
 =head2 method roll
 
-    method roll(Range:D:        ) returns Any:D
-    method roll(Range:D: $number) returns Seq:D
+    multi method roll(Range:D:        ) returns Any:D
+    multi method roll(Range:D: $number) returns Seq:D
 
 Performs the same function as C<Range.list.roll>, but attempts to optimize
 by not actually generating the list if it is not necessary.

doc/Type/Scalar.pod6

@@ -31,31 +31,31 @@ tell if this has been done by examining the introspective pseudo-method
 C<.VAR>:
 
     my $a = 1;
-    $a.WHAT.say;     # says "(Int)"
-    $a.VAR.WHAT.say; # says "(Scalar)"
+    $a.WHAT.say;     # (Int)
+    $a.VAR.WHAT.say; # (Scalar)
     my $b := 1;
-    $b.WHAT.say;     # says "(Int)"
-    $b.VAR.WHAT.say; # says "(Int)"
+    $b.WHAT.say;     # (Int)
+    $b.VAR.WHAT.say; # (Int)
 
 This same thing happens when values are assigned to an element of
 an C<Array>, however, C<List>s directly contain their values:
 
     my @a = 1, 2, 3;
-    @a[0].WHAT.say;            # says "(Int)"
-    @a[0].VAR.WHAT.say;        # says "(Scalar)"
-    [1, 2, 3][0].WHAT.say;     # says "(Int)"
-    [1, 2, 3][0].VAR.WHAT.say; # says "(Scalar)"
-    (1, 2, 3)[0].WHAT.say;     # says "(Int)"
-    (1, 2, 3)[0].VAR.WHAT.say; # says "(Int)"
+    @a[0].WHAT.say;            # (Int)
+    @a[0].VAR.WHAT.say;        # (Scalar)
+    [1, 2, 3][0].WHAT.say;     # (Int)
+    [1, 2, 3][0].VAR.WHAT.say; # (Scalar)
+    (1, 2, 3)[0].WHAT.say;     # (Int)
+    (1, 2, 3)[0].VAR.WHAT.say; # (Int)
 
 Array elements may be bound directly to values using C<:=> as well,
 however this is to be discouraged as it may lead to confusion.
 Doing so will break exact round-tripping of C<.perl> output -- since
 C<Array>s are assumed to place C<Scalar>s around each element,
 C<Scalar>s are not denoted with C<$> in the output of C<Array.perl>.
 
-    [1, $(2, 3)].perl.say      # says [1, (2, 3)]
-    (1, $(2, 3)).perl.say      # says (1, $(2, 3))
+    [1, $(2, 3)].perl.say;     # [1, (2, 3)]
+    (1, $(2, 3)).perl.say;     # (1, $(2, 3))
 
 Binding a Scalar to a C<$>-sigiled variable replaces the existing
 C<Scalar> in that variable, if any, with the given C<Scalar>.
@@ -66,7 +66,7 @@ alter the value of both variables by altering only one of them:
     my $a = 1;
     my $b := $a;
     $b = 2;
-    $a.say;       # says "2"
+    $a.say;       # 2
 
 X<|\ (sigilless scalar)>
 SSA-style constants bind directly to their value with no
@@ -76,13 +76,15 @@ to them, at which point, they behave entirely like C<$>-sigiled
 variables.
 
     my \c = 1;
-    c.WHAT.say;              # says "(Int)"
-    c.VAR.WHAT.say;          # says "(Int)"
+    c.WHAT.say;              # (Int)
+    c.VAR.WHAT.say;          # (Int)
     my $a = 1;
     my \d = $a;              # just "my \d = $ = 1" works, too
-    d.WHAT.say;              # says "(Int)"
-    d.VAR.WHAT.say;          # says "(Scalar)"
+    d.WHAT.say;              # (Int)
+    d.VAR.WHAT.say;          # (Scalar)
     d = 2;                   # ok
-    c = 2;                   # error, cannot modify an immutable Int
+    c = 2;
+    CATCH { default { put .^name, ': ', .Str } };
+    # OUTPUT: «X::Assignment::RO: Cannot modify an immutable Int␤»
 
 =end pod