From a7b7353eab17853603da2a9bf3b54125a3ca51fc Mon Sep 17 00:00:00 2001 From: chromatic Date: Tue, 31 Aug 2010 18:45:18 -0700 Subject: [PATCH] Renumbered =head tags for chapters (GH #102). --- sections/advanced_oo.pod | 14 ++++++------ sections/anonymous_functions.pod | 8 +++---- sections/arrays.pod | 14 ++++++------ sections/attributes.pod | 6 ++--- sections/autoload.pod | 10 ++++----- sections/barewords.pod | 6 ++--- sections/blessed_references.pod | 10 ++++----- sections/builtins.pod | 2 +- sections/chapter_00.pod | 2 +- sections/chapter_01.pod | 2 +- sections/chapter_02.pod | 2 +- sections/chapter_03.pod | 2 +- sections/chapter_04.pod | 2 +- sections/chapter_05.pod | 2 +- sections/chapter_06.pod | 2 +- sections/chapter_07.pod | 2 +- sections/chapter_08.pod | 2 +- sections/chapter_09.pod | 2 +- sections/chapter_10.pod | 2 +- sections/chapter_11.pod | 2 +- sections/chapter_12.pod | 2 +- sections/closures.pod | 8 +++---- sections/code_generation.pod | 10 ++++----- sections/coercion.pod | 14 ++++++------ sections/context_philosophy.pod | 6 ++--- sections/control_flow.pod | 30 ++++++++++++------------- sections/cpan.pod | 2 +- sections/distributions.pod | 8 +++---- sections/exceptions.pod | 10 ++++----- sections/expressivity.pod | 2 +- sections/files.pod | 18 +++++++-------- sections/functions.pod | 32 +++++++++++++-------------- sections/globals.pod | 10 ++++----- sections/handling_warnings.pod | 14 ++++++------ sections/hashes.pod | 18 +++++++-------- sections/idioms.pod | 20 ++++++++--------- sections/implicit_ideas.pod | 6 ++--- sections/indirect_objects.pod | 8 +++---- sections/method_sub_equivalence.pod | 6 ++--- sections/missing_defaults.pod | 10 ++++----- sections/modules.pod | 8 +++---- sections/moose.pod | 26 +++++++++++----------- sections/names.pod | 6 ++--- sections/nested_data_structures.pod | 14 ++++++------ sections/operator_characteristics.pod | 10 ++++----- sections/operator_types.pod | 12 +++++----- sections/overloading.pod | 8 +++---- sections/packages.pod | 4 ++-- sections/perl_community.pod | 8 +++---- sections/perldoc.pod | 2 +- sections/pragmas.pod | 8 +++---- sections/prototypes.pod | 6 ++--- sections/references.pod | 14 ++++++------ sections/reflection.pod | 16 +++++++------- sections/regular_expressions.pod | 26 +++++++++++----------- sections/scalars.pod | 4 ++-- sections/scope.pod | 10 ++++----- sections/smart_match.pod | 2 +- sections/state.pod | 2 +- sections/style.pod | 6 ++--- sections/taint.pod | 12 +++++----- sections/testing.pod | 12 +++++----- sections/tie.pod | 8 +++---- sections/universal.pod | 12 +++++----- sections/values.pod | 24 ++++++++++---------- sections/variables.pod | 10 ++++----- 66 files changed, 299 insertions(+), 299 deletions(-) diff --git a/sections/advanced_oo.pod b/sections/advanced_oo.pod index 7f73d534..30ecfbbd 100644 --- a/sections/advanced_oo.pod +++ b/sections/advanced_oo.pod @@ -1,4 +1,4 @@ -=head2 Advanced OO Perl +=head1 Advanced OO Perl Z @@ -8,7 +8,7 @@ abstraction also offer possibilities for obfuscation. Only practical experience can help you understand the most important design techniques... but several principles can guide you. -=head3 Favor Composition Over Inheritance +=head2 Favor Composition Over Inheritance Novice OO designs often overuse inheritance. It's common to see class hierarchies which try to model all of the behavior for entities within the @@ -27,7 +27,7 @@ roles) improves encapsulation and reduces the possibility that any one class or role will grow to do too much. Smaller, simpler, and better encapsulated entities are easier to understand, test, and maintain. -=head3 Single Responsibility Principle +=head2 Single Responsibility Principle When you design your object system, model the problem in terms of responsibilities, or reasons why each specific entity may need to change. For @@ -42,7 +42,7 @@ may have a C-sharing arrangement, for example.) When each class has a single responsibility, you can improve the encapsulation of class-specific data and behaviors and reduce coupling between classes. -=head3 Don't Repeat Yourself +=head2 Don't Repeat Yourself Complexity and duplication complicate development and maintenance activities. The DRY principle (Don't Repeat Yourself) is a reminder to seek out and to @@ -56,7 +56,7 @@ This principle helps to reduce the possibility that important parts of your system can get unsynchronized, and helps you to find the optimal representation of the system and its data. -=head3 Liskov Substitution Principle +=head2 Liskov Substitution Principle The Liskov substitution principle suggests that subtypes of a given type (specializations of a class or role or subclasses of a class) should be @@ -72,7 +72,7 @@ objects with C objects in the test suite, and everything should passN.>. -=head3 Subtypes and Coercions +=head2 Subtypes and Coercions Z Z @@ -88,7 +88,7 @@ specify mechanisms by which to coerce data of one type to data of another type. See C and C for more information. -=head3 Immutability +=head2 Immutability Z diff --git a/sections/anonymous_functions.pod b/sections/anonymous_functions.pod index 5830296b..2281ea0a 100644 --- a/sections/anonymous_functions.pod +++ b/sections/anonymous_functions.pod @@ -1,4 +1,4 @@ -=head2 Anonymous Functions +=head1 Anonymous Functions Z @@ -11,7 +11,7 @@ references to it--it can do anything a named function can do. The difference is that it has no name. You always deal with anonymous functions by reference (see L and L). -=head3 Declaring Anonymous Functions +=head2 Declaring Anonymous Functions You may never declare an anonymous function on its own; you must construct it and assign it to a variable, invoke it immediately, or pass it as an argument @@ -113,7 +113,7 @@ function parameters: =end programlisting -=head3 Anonymous Function Names +=head2 Anonymous Function Names X @@ -204,7 +204,7 @@ Calling C on C<$anon> and returning into C<$named> modifies that function, so any other reference to this function will see the same name C. -=head3 Implicit Anonymous Functions +=head2 Implicit Anonymous Functions X diff --git a/sections/arrays.pod b/sections/arrays.pod index f6211ba3..93019bdf 100644 --- a/sections/arrays.pod +++ b/sections/arrays.pod @@ -1,4 +1,4 @@ -=head2 Arrays +=head1 Arrays Z X @@ -17,7 +17,7 @@ The C<@> sigil denotes an array. To declare an array: =end programlisting -=head3 Array Elements +=head2 Array Elements X X @@ -101,7 +101,7 @@ You can resize an array by assigning to C<$#>. If you shrink an array, Perl will discard values which do not fit in the resized array. If you expand an array, Perl will fill in the expanded values with C. -=head3 Array Assignment +=head2 Array Assignment You can assign to individual positions in an array directly by index: @@ -174,7 +174,7 @@ version of C. Prefer the latter. =end sidebar -=head3 Array Slices +=head2 Array Slices X X @@ -232,7 +232,7 @@ used as its index: =end programlisting -=head3 Array Operations +=head2 Array Operations Managing array indices can be a hassle. Because Perl 5 can expand or contract arrays as necessary, the language also provides several operations to treat @@ -298,7 +298,7 @@ other operators are shorter and simpler to read and understand. Arrays often contain elements to process in a loop; see L for more detail about Perl 5 control flow and array processing. -=head3 Arrays and Context +=head2 Arrays and Context X @@ -347,7 +347,7 @@ not I lists in these circumstances--they only group expressions. The solution to this flattening behavior is the same for passing arrays to functions and for creating nested arrays (L). -=head3 Array Interpolation +=head2 Array Interpolation X X diff --git a/sections/attributes.pod b/sections/attributes.pod index e56f6486..0da626ab 100644 --- a/sections/attributes.pod +++ b/sections/attributes.pod @@ -1,4 +1,4 @@ -=head2 Attributes +=head1 Attributes Z @@ -15,7 +15,7 @@ they I offer compelling benefits of maintenance and clarity. =end sidebar -=head3 Using Attributes +=head2 Using Attributes In its simplest form, an attribute is a colon-preceded identifier attached to a variable or function declaration: @@ -68,7 +68,7 @@ The Catalyst web framework also uses attributes to determine the visibility and =end sidebar -=head3 Drawbacks of Attributes +=head2 Drawbacks of Attributes X X diff --git a/sections/autoload.pod b/sections/autoload.pod index 1f48e7ce..195b305b 100644 --- a/sections/autoload.pod +++ b/sections/autoload.pod @@ -1,4 +1,4 @@ -=head2 AUTOLOAD +=head1 AUTOLOAD Z @@ -39,7 +39,7 @@ C to emit a message to demonstrate this: =end programlisting -=head3 Basic Features of AUTOLOAD +=head2 Basic Features of AUTOLOAD The C function receives the arguments passed to the undefined function in C<@_> directly. You may manipulate these arguments as you like: @@ -104,7 +104,7 @@ Finally, whatever C returns, the original call receives: So far, these examples have merely intercepted calls to undefined functions. You have other options. -=head3 Redispatching Methods in AUTOLOAD() +=head2 Redispatching Methods in AUTOLOAD() X X @@ -143,7 +143,7 @@ it dereferences the proxied object from a blessed scalar reference, extracts the name of the undefined method, then invokes the method of that name on the proxied object, passing the given arguments. -=head3 Generating Code in AUTOLOAD() +=head2 Generating Code in AUTOLOAD() X @@ -215,7 +215,7 @@ This has the same effect as invoking C<$method> directly, except that C will no longer appear in the list of calls available from C, so it looks like the generated method was simply called directly. -=head3 Drawbacks of AUTOLOAD +=head2 Drawbacks of AUTOLOAD Z diff --git a/sections/barewords.pod b/sections/barewords.pod index 06458b45..326e1442 100644 --- a/sections/barewords.pod +++ b/sections/barewords.pod @@ -1,4 +1,4 @@ -=head2 Barewords +=head1 Barewords Z @@ -23,7 +23,7 @@ for good reason. Even so, barewords are permissible in several places in Perl 5 for good reason. -=head3 Good Uses of Barewords +=head2 Good Uses of Barewords X X @@ -118,7 +118,7 @@ bareword; Perl 5 knows everything it needs to know to parse all occurrences of that function appropriately. Note that all of the drawbacks of prototypes still apply. -=head3 Ill-Advised Uses of Barewords +=head2 Ill-Advised Uses of Barewords X diff --git a/sections/blessed_references.pod b/sections/blessed_references.pod index b5fc690b..a533b7f4 100644 --- a/sections/blessed_references.pod +++ b/sections/blessed_references.pod @@ -1,4 +1,4 @@ -=head2 Blessed References +=head1 Blessed References Z @@ -149,7 +149,7 @@ thing with regard to encapsulation as well as genericity. =end sidebar -=head3 Method Lookup and Inheritance +=head2 Method Lookup and Inheritance X X @@ -255,7 +255,7 @@ behavior with method dispatch. Enable it in your class with: Unless you're writing a complex framework with multiple interoperable plugins, you likely never need to use this. -=head3 AUTOLOAD +=head2 AUTOLOAD X X @@ -270,7 +270,7 @@ for more details. As you might expect, this can get quite complex in the face of multiple inheritance and multiple potential C targets. -=head3 Method Overriding and SUPER +=head2 Method Overriding and SUPER You may override methods in the default Perl 5 OO system as well as in Moose. Unfortunately, core Perl 5 provides no mechanism for indicating your I @@ -310,7 +310,7 @@ can work around this for you. Moose handles it nicely as well. =end sidebar -=head3 Strategies for Coping with Blessed References +=head2 Strategies for Coping with Blessed References Avoid C where possible. If you I use it, use forward declarations of your functions (L) to help Perl know which diff --git a/sections/builtins.pod b/sections/builtins.pod index aed64802..bb2af2b6 100644 --- a/sections/builtins.pod +++ b/sections/builtins.pod @@ -1,4 +1,4 @@ -=head1 Builtins +=head0 Builtins Z