AttributeContainer and Proc/Async now compile

Author: Altai-man

doc/Type/Metamodel/AttributeContainer.pod6

@@ -4,7 +4,7 @@
 
 =SUBTITLE Metaobject that can hold attributes
 
-    role Metamodel::AttributeContainer { ... }
+    role Metamodel::AttributeContainer {}
 
 Classes, roles and grammars can have attributes. Storage and introspection of
 attributes is implemented by this role.
@@ -13,22 +13,22 @@ attributes is implemented by this role.
 
 =head2 method add_attribute
 
-    method add_attribute(Metamodel::AttributeContainer: $obj, $name, $attribute)
+    method add_attribute(Metamodel::AttributeContainer: $obj, $name, $attribute) {}
 
 Adds an attribute. C<$attribute> must be an object that supports the
 methods C<name>,  C<type> and C<package>, which are called without arguments.
 It can for example be of L<type Attribute|/type/Attribute>.
 
 =head2 method attributes
 
-    method attributes(Metamodel::AttributeContainer: $obj)
+    method attributes(Metamodel::AttributeContainer: $obj) {}
 
 Returns a list of attributes. For most Perl 6 types, these will be objects of
 L<type Attribute|/type/Attribute>.
 
 =head2 method set_rw
 
-    method set_rw(Metamodel::AttributeContainer: $obj)
+    method set_rw(Metamodel::AttributeContainer: $obj) {}
 
 Marks a type whose attributes default to having a write accessor. For example
 in
@@ -41,12 +41,14 @@ in
 The C<is rw> trait on the class calls the C<set_rw> method on the meta class,
 making all the attributes implicitly writable, so that you can write;
 
+=begin code :skip-test
     my $p = Point.new(x => 1, y => 2);
     $p.x = 42;
+=end code
 
 =head2 method rw
 
-    method rw(Metamodel::AttributeContainer: $obj)
+    method rw(Metamodel::AttributeContainer: $obj) {}
 
 Returns a true value if L<method set_rw|#method set_rw> has been called on
 this object, that is, if new public attributes are writable by default.

doc/Type/Proc/Async.pod6

@@ -4,7 +4,9 @@
 
 =SUBTITLE Running process (asynchronous interface)
 
-    class Proc::Async { ... }
+=begin code :skip-test
+    class Proc::Async {}
+=end code
 
 B<Note:> only the MoarVM backend of Rakudo implements C<Proc::Async> at the
 moment.
@@ -30,9 +32,11 @@ standard output and error handles, and optionally write to its standard input.
 
 This produces the following output:
 
+=begin code :skip-test
     Starting...
     Output: foo bar
     Done.
+=end code
 
 An example that opens an external program for writing:
 
@@ -47,7 +51,7 @@ An example that opens an external program for writing:
 
 =head2 method new
 
-    method new(:$path, *@args, :$w) returns Proc::Async:D
+    method new(:$path, *@args, :$w) returns Proc::Async:D {}
 
 Creates a new C<Proc::Async> object with external program name or path C<$path>
 and the command line arguments C<@args>.
@@ -58,13 +62,14 @@ C<say>.
 
 =head2 method stdout
 
-    method stdout(Proc::Async:D: :$bin) returns Supply:D
+    method stdout(Proc::Async:D: :$bin) returns Supply:D {}
 
 Returns the L<Supply|/type/Supply> for the external program's standard output
 stream. If C<:bin> is passed, the standard output is passed along in  binary as
 L<Blob|/type/Blob>, otherwise it is interpreted as UTF-8, decoded, and passed
 along as L<Str|/type/Str>.
 
+    my $proc = Proc::Async.new(:r, 'echo', 'Perl 6');
     $proc.stdout.tap( -> $str {
         say "Got output '$str' from the external program";
     });
@@ -82,13 +87,14 @@ you try.
 
 =head2 method stderr
 
-    method stderr(Proc::Async:D: :$bin) returns Supply:D
+    method stderr(Proc::Async:D: :$bin) returns Supply:D {}
 
 Returns the L<Supply|/type/Supply> for the external program's standard error
 stream. If C<:bin> is passed, the standard error is passed along in  binary as
 L<Blob|/type/Blob>, otherwise it is interpreted as UTF-8, decoded, and passed
 along as L<Str|/type/Str>.
 
+    my $proc = Proc::Async.new(:r, 'echo', 'Perl 6');
     $proc.stderr.tap( -> $str {
         say "Got error '$str' from the external program";
     });
@@ -106,15 +112,15 @@ you try.
 
 =head2 method w
 
-    method w(Proc::Async:D:)
+    method w(Proc::Async:D:) {}
 
 Returns a true value if C<:w> was passed to the constructor, that is, if the
 external program is started with its input stream made available to output to
 the program through the C<.print>, C<.say> and C<.write> methods.
 
 =head2 method start
 
-    method start(Proc::Async:D:, :$scheduler = $*SCHEDULER, :$cwd = $*CWD) returns Promise:D
+    method start(Proc::Async:D: :$scheduler = $*SCHEDULER, :$cwd = $*CWD) returns Promise:D {}
 
 Initiates spawning of the external program. Returns a promise that will be
 kept with a L<Proc|/type/Proc> object once the external
@@ -127,38 +133,42 @@ thrown.
 
 Note: If you wish to C<await> the Promise and discard its result, using
 
+=begin code :skip-test
     try await $p.start;
+=end code
 
 B<will throw> if the program exited with non-zero status, as the C<Proc>
 returned as the result of the Promise throws when sunk and in this case it
 will get sunk outside the C<try>. To avoid that, sink it yourself I<inside> the
 C<try>:
 
+=begin code :skip-test
     try sink await $p.start;
+=end code
 
 =head2 method started
 
-    method started(Proc::Async:D:) returns Bool:D
+    method started(Proc::Async:D:) returns Bool:D {}
 
 Returns C<False> before C<.start> has been called, and C<True> afterwards.
 
 =head2 method path
 
-    method path(Proc::Async:D:)
+    method path(Proc::Async:D:) {}
 
 Returns the name and/or path of the external program that was passed to the
 C<new> method as first argument.
 
 =head2 method args
 
-    method args(Proc::Async:D:) returns Positional:D
+    method args(Proc::Async:D:) returns Positional:D {}
 
 Returns the command line arguments for the external programs, as passed to the
 C<new> method.
 
 =head2 method write
 
-    method write(Proc::Async:D: Blob:D $b, :$scheduler = $*SCHEDULER)
+    method write(Proc::Async:D: Blob:D $b, :$scheduler = $*SCHEDULER) {}
 
 Write the binary data in C<$b> to the standard input stream of the external
 program.
@@ -175,7 +185,7 @@ L<X::Proc::Async::MustBeStarted> exception is thrown.
 
 =head2 method print
 
-    method print(Proc::Async:D: Str(Any) $str, :$scheduler = $*SCHEDULER)
+    method print(Proc::Async:D: Str(Any) $str, :$scheduler = $*SCHEDULER) {}
 
 Write the text data in C<$str> to the standard input stream of the external
 program, encoding it as UTF-8.
@@ -192,7 +202,7 @@ L<X::Proc::Async::MustBeStarted> exception is thrown.
 
 =head2 method say
 
-    method say(Proc::Async:D: $output, :$scheduler = $*SCHEDULER)
+    method say(Proc::Async:D: $output, :$scheduler = $*SCHEDULER) {}
 
 Calls method C<gist> on the C<$output>, adds a newline, encodes it as UTF-8,
 and sends it to the standard input stream of the external
@@ -210,7 +220,7 @@ L<X::Proc::Async::MustBeStarted> exception is thrown.
 
 =head2 method close-stdin
 
-    method close-stdin(Proc::Async:D:)
+    method close-stdin(Proc::Async:D:) {}
 
 Closes the standard input stream of the external program. Programs that read
 from STDIN often only terminate when their input stream is closed. So if
@@ -226,7 +236,7 @@ L<X::Proc::Async::MustBeStarted> exception is thrown.
 
 =head2 method kill
 
-    kill(Proc::Async:D: $signal = "HUP")
+    method kill(Proc::Async:D: $signal = "HUP") {}
 
 Sends a signal to the running program. The signal can be a signal name
 ("KILL" or "SIGKILL"), an integer (9) or an element of the C<Signal> enum