TITLE

Modules and applications used to debug Perl 6 programs


SUBTITLE

All types of formatting codes. Only the indexing terms should be processed in 
order to find definitions. The other ones are ignored.


head

All heads below should be parsed as possible definitions.


Type 1 without meta info (this has to be indexed as category only)


# vim: expandtab softtabstop=4 shiftwidth=4 ft=perl6

root

para

L<Examples| file:../examples/index.podlite>


L<Download |file:../download/index.podlite>


React

=begin React :component<HeaderCol> :id<menu> 
=para L<Documentation|/doc/introduction>
=para L<Modules| /mods>
=para L<Examples| file:../examples/index.podlite>
=para L<Download |file:../download/index.podlite>
=para L<About|file:../about/index.podlite>
=para 🔍 K<⌘K>/K<ctrl-K>
=end React


HEADER

FOOTER

Debugging


An easy-to-use markup language for documenting Perl modules and programs


Perl 6 pod is an easy-to-use markup language. Pod can be used for
writing language documentation, for documenting programs and modules, as
well as for other types of document composition.


Every Pod document has to begin with C<=begin pod> and end with C<=end pod>.
Everything between these two delimiters will be processed and used to generate
documentation.


code

=begin code :lang<pod6>
=begin pod

A very simple Perl 6 Pod document

=end pod
=end code


A Pod document may consist of multiple Pod blocks. There are four ways to define
a block: delimited, paragraph, abbreviated, and declarator; the first three
yield the same result but the fourth differs. You can use whichever form is most
convenient for your particular documentation task.


Delimited blocks are bounded by C<=begin> and C<=end> markers, both of
which are followed by a valid Perl 6 identifier, which is the
C<typename> of the block. Typenames that are entirely lowercase (for
example: C<=begin head1>) or entirely uppercase (for example: C<=begin
SYNOPSIS>) are reserved.


=begin code :lang<pod6>
=begin head1
Top Level Heading
=end head1
=end code


After the typename, the rest of the C<=begin> marker line is treated as
configuration information for the block. This information is used in
different ways by different types of blocks, but is always specified using
Perl6-ish option pairs. That is, any of:


table_head

 ===============   ===================       ==============       ===========


table_row

table

=begin table
 Value is...       Specify with...           Or with...           Or with...
 ===============   ===================       ==============       ===========
 List              :key[$e1, $e2, ...]       :key($e1, $e2, ...)  :key<$e1 $e2 ...>
 Hash              :key{$k1=>$v1, $k2=>$v2}
 Boolean (true)    :key                      :key(True)           :key[True]
 Boolean (false)   :!key                     :key(False)          :key[False]
 String            :key<str>                 :key('str')          :key("str")
 Int               :key(42)                  :key[42]             :42key
 Number            :key(2.3)                 :key[2.3]
=end table


Where '$e1, $e2, ...' are list elements of type String, Int, Number, or
Boolean.  Lists may have mixed element types. Note that one-element
lists are converted to the type of their element (String, Int, Number, or
Boolean). Also note that "bigints" can be used if required.


For hashes, '$k1, $k2, ...' are keys of type Str and '$v1, $v2, ...'
are values of type String, Int, Number, or Boolean.


Strings are delimited by single or double quotes.  Whitespace is not significant
outside of strings. Hash keys need not be quote-delimited unless they contain
significant whitespace. Strings entered inside angle brackets become lists if
any whitespace is used inside the angle brackets.


All option keys and values must, of course, be constants since Pod is a
specification language, not a programming language. Specifically, option
values cannot be closures. See Synopsis 2 for details of the various
Perl 6 pair notations.


The configuration section may be extended over subsequent lines by
starting those lines with an C<=> in the first (virtual) column followed
by a whitespace character. N<This feature is not yet completely implemented.
All configuration information currently must be provided on the same
line as the C<=begin> marker line or C<=for name> for paragraph blocks.>


Paragraph blocks begin by a C<=for> marker and end by
the next Pod directive or the first blank line.
The C<=for> marker is followed by the C<typename> of the block
plus, optionally, any configuration data as in the delimited
blocks described above.


=begin code :lang<pod6>
=for head1
Top Level Heading
=end code


Abbreviated blocks begin by an C<'='> sign, which is followed immediately by the
C<typename> of the block. All following data are part of the contents of the
block, thus configuration data B<cannot> be specified for an I<abbreviated>
block. The block ends at the next Pod directive or the first blank line.


=begin code :lang<pod6>
=head1 Top level heading
=end code


X<|declarator blocks,#|>X<|declarator blocks,#=>


Declarator blocks differ from the others by not having a specific type,
instead they are attached to some source code.


Declarator blocks are introduced by a special comment: either C<#|> or C<#=>,
which must be immediately followed by either a space or an opening curly brace.
If followed by a space, the block is terminated by the end of line;
if followed by one or more opening curly braces, the block is terminated by the matching
sequence of closing curly braces.


Blocks starting with C<#|> are attached to the code after them,
and blocks starting with C<#=> are attached to the code before them.


Since declarator blocks are attached to source code, they can be used to
document classes, roles, subroutines and in general any statement or block.


The C<WHY> method can be used on these classes, roles, subroutines etc. to
return the attached Pod value.


=begin code
#| Base class for magicians
class Magician {
  has Int $.level;
  has Str @.spells;
}

#| Fight mechanics
sub duel(Magician $a, Magician $b) {
}
#= Magicians only, no mortals.

say Magician.WHY; # OUTPUT: «Base class for magicians␤»
say &duel.WHY.leading; # OUTPUT: «Fight mechanics␤»
say &duel.WHY.trailing; # OUTPUT: «Magicians only, no mortals.␤»
=end code


These declarations can extend multiple blocks:


=begin code
#|( This is an example of stringification:
    * Numbers turn into strings
    * Regexes operate on said strings
    * C<with> topicalizes and places result into $_
)
sub search-in-seq( Int $end, Int $number ) {
    with (^$end).grep( /^$number/ ) {
        .say for $_<>;
    }
}
#=« Uses
    * topic
    * decont operator
»
=end code


By using a matched pair of parenthesis constructs such as C<()> or C<«»> the
comments can extend multiple lines. This format, however, will not translate to
a multi-line display by C<perl6 -doc>.


Pod offers a wide range of standard block types.


Headings can be defined using C<=headN>,
where N is greater than zero (e.g., C<=head1>, C<=head2>, …).


=begin code :lang<pod6>
=head1 A top level heading

=head2 A second level heading

=head3 A third level heading
=end code


An ordinary paragraph consists of text that is to be formatted into a document
at the current level of nesting, with whitespace squeezed, lines filled, and any
special inline mark-up applied.


Ordinary paragraphs consist of one or more consecutive lines of text,
each of which starts with a non-whitespace character.
The paragraph is terminated by the first blank line or block directive.


=begin code :lang<pod6>
=head1 This is a heading block

This is an ordinary paragraph.
Its text  will   be     squeezed     and
short lines filled. It is terminated by
the first blank line.

This is another ordinary paragraph.
Its     text    will  also be squeezed and
short lines filled. It is terminated by
the trailing directive on the next line.

=head2 This is another heading block

This is yet another ordinary paragraph,
at the first virtual column set by the
previous directive
=end code


Ordinary paragraphs do not require an explicit marker or delimiters.


Alternatively, there is also an explicit C<=para> marker that can be used to explicitly mark a paragraph.


=begin code :lang<pod6>
=para
This is an ordinary paragraph.
Its text  will   be     squeezed     and
short lines filled.
=end code


In addition, the longer C<=begin para> and C<=end para> form can be used.


# vim: expandtab softtabstop=4 shiftwidth=4 ft=perl6


Perl 6 pod


#| Base class for magicians 
class Magician {
  has Int $.level;
  has Str @.spells;
}


#| Flight mechanics 
sub duel(Magician $a, Magician $b) {
}
#= Magicians only, no mortals. 


multi

The Raku Knowledge Base


=begin React :component<HeaderCol> :id<footer>  
=begin nested :!nested
=item1 B<Language>
    =item2 L<Get started|file:../getting-started/getting-started.podlite>
    =item2 L<Why Raku?|/doc/language/faq#Why-should-I-learn-Raku-What's-so-great-about-it>
    =item2 L<Try Raku|https://glot.io/new/raku>
    =item2 L<Raku cheat sheet|https://github.com/Raku/mu/blob/master/docs/Perl6/Cheatsheet/cheatsheet.txt>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<Raku on Exercism|https://exercism.org/tracks/raku>
    =item2 L<Wikipedia|https://en.wikipedia.org/wiki/Raku_(programming_language)>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=end nested
=begin nested :!nested

=item1 B<L<Documentation|/doc>>
    =item2 L<Getting started, Migration guides from other languages, & Tutorials | file:../doc/introduction.podlite>
    =item2 L<Language References|file:../doc/reference.podlite>
    =item2 L<Type Reference| file:../doc/types.podlite>
    =item2 L<Miscellaneous| file:../doc/miscellaneous.podlite>
    =item2 L<FAQs (Frequently Asked Questions)|/doc/language/faq>
    =item2 L<Community|/doc/language/community>
    =item2 L<The list of all documents|file:../doc/index.podlite>

=item1 B<Resources>
    =item2 L<The Raku Guide|https://raku.guide/>
    =item2 L<Books |https://perl6book.com/>
    =item2 L<Rosetta Code | https://www.raku.org/community/rosettacode>

=end nested
=begin nested :!nested

=item1 B<Resoures>
    =item2 L<Download | file:../download/index.podlite>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=item1 B<Learning>
    =item2 L<The Raku Guide|https://raku.guide/>
    =item2 L<Wikibook |https://en.wikibooks.org/wiki/Raku_Programming>
    =item2 L<Books |https://perl6book.com/>
    =item2 L<Rosetta Code | https://www.raku.org/community/rosettacode>
    =item2 L<Learn Raku in Y minutes|https://learnxinyminutes.com/docs/raku/>
    =item2 L<Golfing |https://github.com/AlexDaniel/raku-golf-cheatsheet>
=end nested
=begin nested :!nested

=item1 B<Explore>
    =item2 L<Raku Blog Aggregator|https://planet.raku.org/>
    =item2 L<Rakudo Weekly|https://rakudoweekly.blog/>
    =item2 L<The Weekly Challenge |https://perlweeklychallenge.org/>
    =item2 L<Raku Advent Calendar|https://raku-advent.blog/>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=end nested
=end React


=begin React :component<CookieConsent> :id<CookieConsent> :buttonCaption("Got it!")
=para
This website uses cookies for analytics.
=end React


Debugging

Formatting::Different::X

`Formatting::Different::X`

〹

Formatting::Different::X

`Formatting::Different::X`

Formatting::Different::X

^[1]

P<Formatting::Different::X>

`Formatting::Different::X`

`Formatting::Different::X`

Formatting::Different::X

INTRODUCTION

p6doc

The arrow operator

The `anon` declarator

Block phasers

postcircumfix `( )`

trait is export

Pod::Load v0.6.0

Authors

License

Dependencies

Test Dependencies

Provides

Documentation

Formatting::Different::X

Formatting::Different::X

〹

Formatting::Different::X

Formatting::Different::X

Formatting::Different::X

[1]

P<Formatting::Different::X>

Formatting::Different::X

Formatting::Different::X

Formatting::Different::X

INTRODUCTION

p6doc

The arrow operator

The anon declarator

Block phasers

postcircumfix ( )

trait is export

Pod::Load v0.6.0

Authors

License

Dependencies

Test Dependencies

Provides

Documentation

`Formatting::Different::X`

`Formatting::Different::X`

^[1]

`Formatting::Different::X`

`Formatting::Different::X`

The `anon` declarator

postcircumfix `( )`