SYNOPSISLet's use the X<> POD formatting code for indexing the Perl core documentation. This will allow easier searching of the documentation, and can be incorporated into tools like perldoc or third-party websites.
REASONOne common problem with using the perl docs is to figure out where to look for something (in perlop, perlre, perlfunc...?).
It is easy to search for a function in perlfunc using perldoc -f, or to search questions from the faq using perldoc -q. But if one wants to search for variables, operators, random topics, etc. there's really no easy way to do it (there is perltoc.pod, but it's huge and usually not very helpful for this purpose).
Some websites such as search.cpan.org and perldoc.perl.org provide search engines for the perl documentation; however, search engines tend to have a couple of limitations:
1) they usually don't handle "line noise" ;-) very well. That is, searching for things like $*.
2) even if they are able to search for such things, they tend to return too many results and have no way of telling which place is the best "canonical definition" for a term.
This document proposes addressing this problem with a hand-curated index to the perl documentation.
BACKGROUND The little-known (or at least little-used) X<> code is described in perlpod: "X<topic name>" -- an index entry This is ignored by most formatters, but some may use it for build- ing indexes. It always renders as empty-string. Example: "X<abso- lutizing relative URLs>"Currently it is used in only *one* place in the perl documentation: pod/perlfunc.pod uses it for the "-X" filetest operators.
Recently I proposed a patch to Pod::Perldoc to allow users to search for perl variables in perlvar with perldoc -a, similar to the use of perldoc -f for functions. Now I have a more ambitious plan: allowing users to search for arbitrary keywords, with, let's say, perldoc -k. The keywords would come from an index created by extracting all X<> terms from the documentation.
The details of how perldoc would handle the proposed -k switch can be discussed later. This document will focus on the basic infrastructure; that is, the conventions for the use of X<> in the documentation. The reason for keeping the discussion separate is that the two problems are largely independent; it is expected that other documentation tools and websites can also benefit from using the X<> data.
PROPOSED CONVENTIONS I. Placement of the X<> entriesFirst, a definition. By "scope", I mean the part of the document that is deemed relevant to an index entry, and that may be extracted and shown in isolation by a processing or display tool. For example, perldoc -f considers the scope of a function to end at the beginning of the next =item, or at the end of the enclosing =over.
The X<> entries should be added at the end of a command or textblock paragraph (verbatim paragraphs are excluded). The scope of the index entry starts at the beginning of the paragraph to which it was attached; the end of the scope depends on the command type:
1) if the X<> is at the end of a textblock, the scope is that paragraph and zero or more verbatim paragraphs immediately following it.
2) if the X<> is at the end of a command paragraph, it depends on the type of command:
* =head1, head2, etc.: The scope ends right before the next
heading with equal or higher level. That is, a =head1 ends
at the next =head1, and a =head2 ends at the next =head2 or
=head1.
* =item: the scope ends right before the next =item, or the =back
that terminates the containing list. Note: "empty" items are
not counted for terminating scopes, to allow for cases where
multiple =items head a block of text. For example,
=item function
X<function>
X<otherfunction>
=item otherfunction
C<function> and C<otherfunction> do the same thing,
even if they have different names...
=item lemonade
Here the scope of the X<function> and X<otherfunction> entries starts
with "=item function", and ends right before "=item lemonade".
3) other command paragraphs, such as =back, =over, =begin, =end, and =for should not be used for attaching X<> entries.
II. Content of the X<> entry.* It should contain plain text without further formatting codes (with the possible exception of E<>).
* It should be considered case-insensitive.* Non-word characters are allowed, so one can list things like operators and special variables.
* Use of synonyms is encouraged, to make things easier to find.* To be consistent, words should be normalized to the singular whenever possible. For example, use X<operator> instead of X<operators>.
* The use of a comma in an index entry has a special meaning: it separates levels of hierarchy (or namespaces), as a way of classifying entries in more specific ways. For example, "X<operator, logical>", or "X<operator, logical, xor>". This information may be used by processing programs to arrange the entries, or for listing results when a user searches for a namespace that contains several entries.
* There's no limitation as to the number of times that a given entry can appear in a document or collection of documents. That is, it is not an error to have X<whatever> appear twice in the same file.
EXAMPLEAs an initial example of an indexed pod file, I'm attaching a patch for perlop.pod that adds X<> entries ("perlop-index.diff"). This patch was prepared as a quick example, so it should not be considered definitive.
The attached program "podindex.pl" is a simple example of how one can extract the index entries from pod files to generate a sorted index file.
The sample output from running ./podindex.pl perlop.pod perlfunc.pod is attached as "index.txt". This index file contains the filename and line number for each entry, and it could be easily used for lookups by means of the Search::Dict module, or loaded into a database.
PLAN OF ACTIONPerl comes with over 100 files in the pod/ directory, totaling over 100,000 lines of POD. Obviously, indexing all of it by hand is a very large task, so the question arises as to who will do it. If people agree that this is a good idea and are willing to apply the patches, I could lead the project, and hope to attracting volunteers. In the worst case (no one else is willing to help), I believe that even if I can't index *all* of the pods, a partial index is better than no index at all. I would start with the documents that I consider more important, such as perlop, perlsub, perlre, perlobj, etc. Documents such as perldelta* and the faqs probably don't need indexing that much.
Initially, this project will focus solely on the files in the pod/ directory. In the long, long term we can also consider indexing the pods that come with the core modules.
AUTHOR Ivan Tubert-Brohman <[EMAIL PROTECTED]>
podindex.pl
Description: Perl program
--- perlop.pod.orig 2005-07-26 12:50:57.799297077 -0400
+++ perlop.pod 2005-07-26 12:51:06.391304255 -0400
@@ -1,10 +1,14 @@
=head1 NAME
+X<operator>
perlop - Perl operators and precedence
=head1 DESCRIPTION
-=head2 Operator Precedence and Associativity
+=head2 Operator Precedence and Associativity
+X<operator, precedence>
+X<precedence>
+X<associativity>
Operator precedence and associativity work in Perl more or less like
they do in mathematics.
@@ -58,6 +62,9 @@
Many operators can be overloaded for objects. See L<overload>.
=head2 Terms and List Operators (Leftward)
+X<list operator>
+X<operator, list>
+X<term>
A TERM has the highest precedence in Perl. They include variables,
quote and quote-like operators, any expression in parentheses,
@@ -119,6 +126,9 @@
as well as L<"I/O Operators">.
=head2 The Arrow Operator
+X<arrow>
+X<dereference>
+X<< -> >>
"C<< -> >>" is an infix dereference operator, just as it is in C
and C++. If the right side is either a C<[...]>, C<{...}>, or a
@@ -134,6 +144,12 @@
or a class name (that is, a package name). See L<perlobj>.
=head2 Auto-increment and Auto-decrement
+X<increment>
+X<auto-increment>
+X<++>
+X<decrement>
+X<auto-decrement>
+X<-->
"++" and "--" work as in C. That is, if placed before a variable,
they increment or decrement the variable by one before returning the
@@ -175,6 +191,9 @@
The auto-decrement operator is not magical.
=head2 Exponentiation
+X<**>
+X<exponentiation>
+X<power>
Binary "**" is the exponentiation operator. It binds even more
tightly than unary minus, so -2**4 is -(2**4), not (-2)**4. (This is
@@ -182,9 +201,12 @@
internally.)
=head2 Symbolic Unary Operators
+X<unary operator>
+X<operator, unary>
Unary "!" performs logical negation, i.e., "not". See also C<not> for a lower
precedence version of this.
+X<!>
Unary "-" performs arithmetic negation if the operand is numeric. If
the operand is an identifier, a string consisting of a minus sign
@@ -192,6 +214,8 @@
starts with a plus or minus, a string starting with the opposite sign
is returned. One effect of these rules is that -bareword is equivalent
to the string "-bareword".
+X<->
+X<negation, arithmetic>
Unary "~" performs bitwise negation, i.e., 1's complement. For
example, C<0666 & ~027> is 0640. (See also L<Integer Arithmetic> and
@@ -199,18 +223,27 @@
platform-dependent: ~0 is 32 bits wide on a 32-bit platform, but 64
bits wide on a 64-bit platform, so if you are expecting a certain bit
width, remember to use the & operator to mask off the excess bits.
+X<~>
+X<negation, binary>
Unary "+" has no effect whatsoever, even on strings. It is useful
syntactically for separating a function name from a parenthesized expression
that would otherwise be interpreted as the complete list of function
arguments. (See examples above under L<Terms and List Operators (Leftward)>.)
+X<+>
Unary "\" creates a reference to whatever follows it. See L<perlreftut>
and L<perlref>. Do not confuse this behavior with the behavior of
backslash within a string, although both forms do convey the notion
of protecting the next thing from interpolation.
+X<\>
+X<reference>
=head2 Binding Operators
+X<binding>
+X<operator, binding>
+X<=~>
+X<!~>
Binary "=~" binds a scalar expression to a pattern match. Certain operations
search or modify the string $_ by default. This operator makes that kind
@@ -230,10 +263,13 @@
the logical sense.
=head2 Multiplicative Operators
+X<operator, multiplicative>
Binary "*" multiplies two numbers.
+X<*>
Binary "/" divides two numbers.
+X</>
Binary "%" computes the modulus of two numbers. Given integer
operands C<$a> and C<$b>: If C<$b> is positive, then C<$a % $b> is
@@ -245,6 +281,7 @@
to the modulus operator as implemented by your C compiler. This
operator is not as well defined for negative operands, but it will
execute faster.
+X<%>
Binary "x" is the repetition operator. In scalar context or if the left
operand is not enclosed in parentheses, it returns a string consisting
@@ -253,6 +290,7 @@
parentheses or is a list formed by C<qw/STRING/>, it repeats the list.
If the right operand is zero or negative, it returns an empty string
or an empty list, depending on the context.
+X<%>
print '-' x 80; # print row of dashes
@@ -263,14 +301,27 @@
=head2 Additive Operators
+X<operator, additive>
Binary "+" returns the sum of two numbers.
+X<+>
Binary "-" returns the difference of two numbers.
+X<->
Binary "." concatenates two strings.
+X<string, concatenation>
+X<concatenation>
+X<.>
=head2 Shift Operators
+X<shift operator>
+X<operator, shift>
+X<<< << >>>
+X<<< >> >>>
+X<right shift>
+X<left shift>
+X<bitwise shift>
Binary "<<" returns the value of its left argument shifted left by the
number of bits specified by the right argument. Arguments should be
@@ -293,6 +344,7 @@
of bits is also undefined.
=head2 Named Unary Operators
+X<operator, named unary>
The various named unary operators are treated as functions with one
argument, with optional parentheses.
@@ -324,42 +376,59 @@
treated like named unary operators, but they don't follow this functional
parenthesis rule. That means, for example, that C<-f($file).".bak"> is
equivalent to C<-f "$file.bak">.
+X<-X>
+X<filetest>
+X<operator, filetest>
See also L<"Terms and List Operators (Leftward)">.
=head2 Relational Operators
+X<relational operator>
+X<operator, relational>
Binary "<" returns true if the left argument is numerically less than
the right argument.
+X<< < >>
Binary ">" returns true if the left argument is numerically greater
than the right argument.
+X<< > >>
Binary "<=" returns true if the left argument is numerically less than
or equal to the right argument.
+X<< <= >>
Binary ">=" returns true if the left argument is numerically greater
than or equal to the right argument.
+X<< >= >>
Binary "lt" returns true if the left argument is stringwise less than
the right argument.
+X<< lt >>
Binary "gt" returns true if the left argument is stringwise greater
than the right argument.
+X<< gt >>
Binary "le" returns true if the left argument is stringwise less than
or equal to the right argument.
+X<< le >>
Binary "ge" returns true if the left argument is stringwise greater
than or equal to the right argument.
+X<< ge >>
=head2 Equality Operators
+X<equality>
+X<operator, equality>
Binary "==" returns true if the left argument is numerically equal to
the right argument.
+X<==>
Binary "!=" returns true if the left argument is numerically not equal
to the right argument.
+X<!=>
Binary "<=>" returns -1, 0, or 1 depending on whether the left
argument is numerically less than, equal to, or greater than the right
@@ -368,24 +437,31 @@
"<=" or ">=" anything (even NaN), so those 5 return false. NaN != NaN
returns true, as does NaN != anything else. If your platform doesn't
support NaNs then NaN is just a string with numeric value 0.
+X<< <=> >>
perl -le '$a = NaN; print "No NaN support here" if $a == $a'
perl -le '$a = NaN; print "NaN support here" if $a != $a'
Binary "eq" returns true if the left argument is stringwise equal to
the right argument.
+X<eq>
Binary "ne" returns true if the left argument is stringwise not equal
to the right argument.
+X<ne>
Binary "cmp" returns -1, 0, or 1 depending on whether the left
argument is stringwise less than, equal to, or greater than the right
argument.
+X<cmp>
"lt", "le", "ge", "gt" and "cmp" use the collation (sort) order specified
by the current locale if C<use locale> is in effect. See L<perllocale>.
=head2 Bitwise And
+X<operator, bitwise, and>
+X<bitwise and>
+X<&>
Binary "&" returns its operands ANDed together bit by bit.
(See also L<Integer Arithmetic> and L<Bitwise String Operators>.)
@@ -396,6 +472,12 @@
print "Even\n" if ($x & 1) == 0;
=head2 Bitwise Or and Exclusive Or
+X<operator, bitwise, or>
+X<bitwise or>
+X<|>
+X<operator, bitwise, xor>
+X<bitwise xor>
+X<^>
Binary "|" returns its operands ORed together bit by bit.
(See also L<Integer Arithmetic> and L<Bitwise String Operators>.)
@@ -409,6 +491,9 @@
print "false\n" if (8 | 2) != 10;
=head2 C-style Logical And
+X<&&>
+X<logical and>
+X<operator, logical, and>
Binary "&&" performs a short-circuit logical AND operation. That is,
if the left operand is false, the right operand is not even evaluated.
@@ -416,6 +501,8 @@
is evaluated.
=head2 C-style Logical Or
+X<||>
+X<operator, logical, or>
Binary "||" performs a short-circuit logical OR operation. That is,
if the left operand is true, the right operand is not even evaluated.
@@ -423,6 +510,8 @@
is evaluated.
=head2 C-style Logical Defined-Or
+X<//>
+X<operator, logical, defined-or>
Although it has no direct equivalent in C, Perl's C<//> operator is related
to its C-style or. In fact, it's exactly the same as C<||>, except that it
@@ -464,6 +553,10 @@
Using "or" for assignment is unlikely to do what you want; see below.
=head2 Range Operators
+X<operator, range>
+X<range>
+X<..>
+X<...>
Binary ".." is the range operator, which is really two different
operators depending on the context. In list context, it returns a
@@ -595,6 +688,10 @@
@list = (2.18 .. 3.14); # same as @list = (2 .. 3);
=head2 Conditional Operator
+X<operator, conditional>
+X<operator, ternary>
+X<ternary>
+X<?:>
Ternary "?:" is the conditional operator, just as in C. It works much
like an if-then-else. If the argument before the ? is true, the
@@ -634,6 +731,24 @@
$a += ($a % 2) ? 10 : 2;
=head2 Assignment Operators
+X<assignment>
+X<operator, assignment>
+X<=>
+X<**=>
+X<+=>
+X<*=>
+X<&=>
+X<<< <<= >>>
+X<&&=>
+X<-=>
+X</=>
+X<|=>
+X<<< >>= >>>
+X<||=>
+X<.=>
+X<%=>
+X<^=>
+X<x=>
"=" is the ordinary assignment operator.
@@ -679,6 +794,9 @@
side of the assignment.
=head2 Comma Operator
+X<comma>
+X<operator, comma>
+X<,>
Binary "," is the comma operator. In scalar context it evaluates
its left argument, throws that value away, then evaluates its right
@@ -714,6 +832,8 @@
login( $username => $password );
=head2 List Operators (Rightward)
+X<operator, list, rightward>
+X<list operator>
On the right side of a list operator, it has very low precedence,
such that it controls all comma-separated expressions found there.
@@ -727,11 +847,15 @@
See also discussion of list operators in L<Terms and List Operators
(Leftward)>.
=head2 Logical Not
+X<operator, logical, not>
+X<not>
Unary "not" returns the logical negation of the expression to its right.
It's the equivalent of "!" except for the very low precedence.
=head2 Logical And
+X<operator, logical, and>
+X<and>
Binary "and" returns the logical conjunction of the two surrounding
expressions. It's equivalent to && except for the very low
@@ -739,6 +863,14 @@
expression is evaluated only if the left expression is true.
=head2 Logical or, Defined or, and Exclusive Or
+X<operator, logical, or>
+X<operator, logical, xor>
+X<operator, logical, err>
+X<operator, logical, defined or>
+X<operator, logical, exclusive or>
+X<or>
+X<xor>
+X<err>
Binary "or" returns the logical disjunction of the two surrounding
expressions. It's equivalent to || except for the very low precedence.
@@ -772,6 +904,11 @@
It cannot short circuit, of course.
=head2 C Operators Missing From Perl
+X<operator, missing from perl>
+X<&>
+X<*>
+X<typecasting>
+X<(TYPE)>
Here is what C has that Perl doesn't:
@@ -793,6 +930,26 @@
=back
=head2 Quote and Quote-like Operators
+X<operator, quote>
+X<operator, quote-like>
+X<q>
+X<qq>
+X<qx>
+X<qw>
+X<m>
+X<qr>
+X<s>
+X<tr>
+X<'>
+X<''>
+X<">
+X<"">
+X<//>
+X<`>
+X<``>
+X<<< << >>>
+X<escape sequence>
+
While we usually think of quotes as literal values, in Perl they
function as operators, providing various kinds of interpolating and
@@ -890,6 +1047,13 @@
and although they often accept just C<"\012">, they seldom tolerate just
C<"\015">. If you get in the habit of using C<"\n"> for networking,
you may be burned some day.
+X<newline>
+X<line terminator>
+X<eol>
+X<end of line>
+X<\n>
+X<\r>
+X<\r\n>
For constructs that do interpolate, variables beginning with "C<$>"
or "C<@>" are interpolated. Subscripted variables such as C<$a[3]> or
@@ -919,6 +1083,7 @@
variables when used within double quotes.
=head2 Regexp Quote-Like Operators
+X<operator, regexp>
Here are the quote-like operators that apply to pattern
matching and related activities.
@@ -926,6 +1091,7 @@
=over 8
=item ?PATTERN?
+X<?>
This is just like the C</pattern/> search, except that it matches only
once between calls to the reset() operator. This is a useful
@@ -946,6 +1112,10 @@
around the year 2168.
=item m/PATTERN/cgimosx
+X<m>
+X<operator, match>
+X<regexp, options>
+X<regexp>
=item /PATTERN/cgimosx
@@ -1127,6 +1297,10 @@
MiXeD line-noise. That's all!
=item q/STRING/
+X<q>
+X<quote, double>
+X<'>
+X<''>
=item C<'STRING'>
@@ -1139,6 +1313,10 @@
$baz = '\n'; # a two-character string
=item qq/STRING/
+X<qq>
+X<quote, double>
+X<">
+X<"">
=item "STRING"
@@ -1150,6 +1328,7 @@
$baz = "\n"; # a one-character string
=item qr/STRING/imosx
+X<qr>
This operator quotes (and possibly compiles) its I<STRING> as a regular
expression. I<STRING> is interpolated the same way as I<PATTERN>
@@ -1207,6 +1386,10 @@
for a detailed look at the semantics of regular expressions.
=item qx/STRING/
+X<qx>
+X<`>
+X<``>
+X<backtick>
=item `STRING`
@@ -1288,6 +1471,9 @@
See L<"I/O Operators"> for more discussion.
=item qw/STRING/
+X<qw>
+X<quote, list>
+X<quote, words>
Evaluates to a list of the words extracted out of STRING, using embedded
whitespace as the word delimiters. It can be understood as being roughly
@@ -1316,6 +1502,10 @@
produces warnings if the STRING contains the "," or the "#" character.
=item s/PATTERN/REPLACEMENT/egimosx
+X<substitute>
+X<replace>
+X<regexp, replace>
+X<regexp, substitute>
Searches a string for a pattern, and if found, replaces that pattern
with the replacement text and returns the number of substitutions
@@ -1423,6 +1613,9 @@
1 while s/\t+/' ' x (length($&)*8 - length($`)%8)/e;
=item tr/SEARCHLIST/REPLACEMENTLIST/cds
+X<tr>
+X<y>
+X<transliterate>
=item y/SEARCHLIST/REPLACEMENTLIST/cds
@@ -1512,6 +1705,10 @@
eval "tr/$oldlist/$newlist/, 1" or die $@;
=item <<EOF
+X<here-doc>
+X<heredoc>
+X<here-document>
+X<<< << >>>
A line-oriented form of quoting is based on the shell "here-document"
syntax. Following a C<< << >> you specify a string to terminate
@@ -1606,6 +1803,7 @@
=back
=head2 Gory details of parsing quoted constructs
+X<quote, gory details>
When presented with something that might have several different
interpretations, Perl uses the B<DWIM> (that's "Do What I Mean")
@@ -1686,6 +1884,7 @@
used in parsing.
=item Interpolation
+X<interpolation>
The next step is interpolation in the text obtained, which is now
delimiter-independent. There are four different cases.
@@ -1799,6 +1998,7 @@
which are processed further.
=item Interpolation of regular expressions
+X<regexp, interpolation>
Previous steps were performed during the compilation of Perl code,
but this one happens at run time--although it may be optimized to
@@ -1837,6 +2037,7 @@
switch documented in L<perlrun/"Command Switches">.
=item Optimization of regular expressions
+X<regexp, optimization>
This step is listed for completeness only. Since it does not change
semantics, details of this step are not documented and are subject
@@ -1849,6 +2050,9 @@
=back
=head2 I/O Operators
+X<operator, i/o>
+X<operator, io>
+X<io>
There are several I/O operators you should know about.
@@ -2066,6 +2270,8 @@
@files = glob($files[$i]);
=head2 Constant Folding
+X<constant folding>
+X<folding>
Like C, Perl does a certain amount of expression evaluation at
compile time whenever it determines that all arguments to an
@@ -2088,6 +2294,8 @@
represents so that the interpreter won't have to.
=head2 No-ops
+X<no-op>
+X<nop>
Perl doesn't officially have a no-op operator, but the bare constants
C<0> and C<1> are special-cased to not produce a warning in a void
@@ -2096,6 +2304,7 @@
1 while foo();
=head2 Bitwise String Operators
+X<operator, bitwise, string>
Bitstrings of any size may be manipulated by the bitwise operators
(C<~ | & ^>).
@@ -2130,6 +2339,7 @@
in a bit vector.
=head2 Integer Arithmetic
+X<integer>
By default, Perl assumes that it must do most of its arithmetic in
floating point. But by saying
@@ -2158,6 +2368,10 @@
machines.
=head2 Floating-point Arithmetic
+X<floating-point>
+X<floating point>
+X<float>
+X<real>
While C<use integer> provides integer-only arithmetic, there is no
analogous mechanism to provide automatic rounding or truncation to a
@@ -2200,6 +2414,7 @@
need yourself.
=head2 Bigger Numbers
+X<number, arbitrary precision>
The standard Math::BigInt and Math::BigFloat modules provide
variable-precision arithmetic and overloaded operators, although
! perlop.pod:207 != perlop.pod:429 !~ perlop.pod:242 " perlop.pod:932 " perlop.pod:1315 "" perlop.pod:932 "" perlop.pod:1315 % perlop.pod:274 % perlop.pod:286 %= perlop.pod:733 & perlop.pod:461 & perlop.pod:906 && perlop.pod:493 &&= perlop.pod:733 &= perlop.pod:733 ' perlop.pod:932 ' perlop.pod:1299 '' perlop.pod:932 '' perlop.pod:1299 (TYPE) perlop.pod:906 * perlop.pod:268 * perlop.pod:906 ** perlop.pod:193 **= perlop.pod:733 *= perlop.pod:733 + perlop.pod:229 + perlop.pod:306 ++ perlop.pod:146 += perlop.pod:733 , perlop.pod:796 - perlop.pod:211 - perlop.pod:309 -- perlop.pod:146 -= perlop.pod:733 -> perlop.pod:128 -A perlfunc.pod:255 -B perlfunc.pod:255 -C perlfunc.pod:255 -M perlfunc.pod:255 -O perlfunc.pod:255 -R perlfunc.pod:255 -S perlfunc.pod:255 -T perlfunc.pod:255 -W perlfunc.pod:255 -X perlfunc.pod:255 -X perlop.pod:375 -b perlfunc.pod:255 -c perlfunc.pod:255 -d perlfunc.pod:255 -e perlfunc.pod:255 -f perlfunc.pod:255 -g perlfunc.pod:255 -k perlfunc.pod:255 -l perlfunc.pod:255 -o perlfunc.pod:255 -p perlfunc.pod:255 -r perlfunc.pod:255 -s perlfunc.pod:255 -t perlfunc.pod:255 -u perlfunc.pod:255 -w perlfunc.pod:255 -x perlfunc.pod:255 -z perlfunc.pod:255 . perlop.pod:312 .. perlop.pod:555 ... perlop.pod:555 .= perlop.pod:733 / perlop.pod:271 // perlop.pod:512 // perlop.pod:932 /= perlop.pod:733 < perlop.pod:389 << perlop.pod:317 << perlop.pod:932 << perlop.pod:1707 <<= perlop.pod:733 <= perlop.pod:397 <=> perlop.pod:433 = perlop.pod:733 == perlop.pod:425 =~ perlop.pod:242 > perlop.pod:393 >= perlop.pod:401 >> perlop.pod:317 >>= perlop.pod:733 ? perlop.pod:1093 ?: perlop.pod:690 \ perlop.pod:235 \n perlop.pod:1037 \r perlop.pod:1037 \r\n perlop.pod:1037 ^ perlop.pod:474 ^= perlop.pod:733 ` perlop.pod:932 ` perlop.pod:1388 `` perlop.pod:932 `` perlop.pod:1388 and perlop.pod:856 arrow perlop.pod:128 assignment perlop.pod:733 associativity perlop.pod:8 auto-decrement perlop.pod:146 auto-increment perlop.pod:146 backtick perlop.pod:1388 binding perlop.pod:242 bitwise and perlop.pod:461 bitwise or perlop.pod:474 bitwise shift perlop.pod:317 bitwise xor perlop.pod:474 cmp perlop.pod:453 comma perlop.pod:796 concatenation perlop.pod:312 constant folding perlop.pod:2272 decrement perlop.pod:146 dereference perlop.pod:128 end of line perlop.pod:1037 eol perlop.pod:1037 eq perlop.pod:445 equality perlop.pod:421 err perlop.pod:865 escape sequence perlop.pod:932 exponentiation perlop.pod:193 filetest perlop.pod:375 float perlop.pod:2370 floating point perlop.pod:2370 floating-point perlop.pod:2370 folding perlop.pod:2272 ge perlop.pod:417 gt perlop.pod:409 here-doc perlop.pod:1707 here-document perlop.pod:1707 heredoc perlop.pod:1707 increment perlop.pod:146 integer perlop.pod:2341 interpolation perlop.pod:1886 io perlop.pod:2052 le perlop.pod:413 left shift perlop.pod:317 line terminator perlop.pod:1037 list operator perlop.pod:64 list operator perlop.pod:834 logical and perlop.pod:493 lt perlop.pod:405 m perlop.pod:932 m perlop.pod:1114 ne perlop.pod:449 negation, arithmetic perlop.pod:211 negation, binary perlop.pod:220 newline perlop.pod:1037 no-op perlop.pod:2296 nop perlop.pod:2296 not perlop.pod:849 number, arbitrary precision perlop.pod:2416 operator perlop.pod:1 operator, additive perlop.pod:303 operator, assignment perlop.pod:733 operator, binding perlop.pod:242 operator, bitwise, and perlop.pod:461 operator, bitwise, or perlop.pod:474 operator, bitwise, string perlop.pod:2306 operator, bitwise, xor perlop.pod:474 operator, comma perlop.pod:796 operator, conditional perlop.pod:690 operator, equality perlop.pod:421 operator, filetest perlop.pod:375 operator, i/o perlop.pod:2052 operator, io perlop.pod:2052 operator, list perlop.pod:64 operator, list, rightward perlop.pod:834 operator, logical, and perlop.pod:493 operator, logical, and perlop.pod:856 operator, logical, defined or perlop.pod:865 operator, logical, defined-or perlop.pod:512 operator, logical, err perlop.pod:865 operator, logical, exclusive or perlop.pod:865 operator, logical, not perlop.pod:849 operator, logical, or perlop.pod:503 operator, logical, or perlop.pod:865 operator, logical, xor perlop.pod:865 operator, match perlop.pod:1114 operator, missing from perl perlop.pod:906 operator, multiplicative perlop.pod:265 operator, named unary perlop.pod:346 operator, precedence perlop.pod:8 operator, quote perlop.pod:932 operator, quote-like perlop.pod:932 operator, range perlop.pod:555 operator, regexp perlop.pod:1085 operator, relational perlop.pod:385 operator, shift perlop.pod:317 operator, ternary perlop.pod:690 operator, unary perlop.pod:203 or perlop.pod:865 power perlop.pod:193 precedence perlop.pod:8 q perlop.pod:932 q perlop.pod:1299 qq perlop.pod:932 qq perlop.pod:1315 qr perlop.pod:932 qr perlop.pod:1330 quote, double perlop.pod:1299 quote, double perlop.pod:1315 quote, gory details perlop.pod:1805 quote, list perlop.pod:1473 quote, words perlop.pod:1473 qw perlop.pod:932 qw perlop.pod:1473 qx perlop.pod:932 qx perlop.pod:1388 range perlop.pod:555 real perlop.pod:2370 reference perlop.pod:235 regexp perlop.pod:1114 regexp, interpolation perlop.pod:2000 regexp, optimization perlop.pod:2039 regexp, options perlop.pod:1114 regexp, replace perlop.pod:1504 regexp, substitute perlop.pod:1504 relational operator perlop.pod:385 replace perlop.pod:1504 right shift perlop.pod:317 s perlop.pod:932 shift operator perlop.pod:317 string, concatenation perlop.pod:312 substitute perlop.pod:1504 term perlop.pod:64 ternary perlop.pod:690 tr perlop.pod:932 tr perlop.pod:1615 transliterate perlop.pod:1615 typecasting perlop.pod:906 unary operator perlop.pod:203 x= perlop.pod:733 xor perlop.pod:865 y perlop.pod:1615 | perlop.pod:474 |= perlop.pod:733 || perlop.pod:503 ||= perlop.pod:733 ~ perlop.pod:220
