Index

A note on the digital index

A link in an index entry is displayed as the section title in which that entry appears. Because some sections have multiple index markers, it is not unusual for an entry to have several links to the same section. Clicking on any link will take you directly to the place in the text in which the marker appears.

Symbols

# (pound sign), Exercise 2 [30 min], Writing Tests with Test::Simple

& (ampersand), Referencing a Named Subroutine, Selecting What to Import

() (parentheses), Creating an Anonymous Array Directly, Referencing a Named Subroutine, Exercise [30 min]

+ (plus sign), Creating an Anonymous Hash, Nested Object Destruction

, (comma), Creating an Anonymous Hash

: (colon), Extending @INC with PERL5LIB

:: (double colon), Packages as Namespace Separators, What use Is Doing

; (semicolon), Creating an Anonymous Hash, Closures

<=> (spaceship operator), Review of Sorting

= operator, Exercise (Exercise [30 min])

?: operator, Making a Method Work with Either Classes or Instances

$@ variable, Inserting Code with eval, Using require

@_ array, The Cure for the Common Code, Performing the Same Task on Many Arrays, Performing the Same Task on Many Arrays, Dereferencing the Array Reference, Nested Data Structures, More than One Reference to Data, What to Do with @_, Accessing the Instance Data

accessing instance data, Accessing the Instance Data

changes reflected, Performing the Same Task on Many Arrays

creating, Performing the Same Task on Many Arrays

dereferencing and, Dereferencing the Array Reference

nested data structures, Nested Data Structures

passing uninterrupted, What to Do with @_

references and scoping, More than One Reference to Data

removing items from, The Cure for the Common Code

[] (square brackets), Creating an Anonymous Array Directly, Creating an Anonymous Array Directly

\ (backslash), Taking a Reference to an Array, References to Hashes, Referencing a Named Subroutine

_ (underscore), Packages as Namespace Separators

{} (curly braces), Dereferencing the Array Reference, Dropping Those Braces, Dropping Those Braces, Simplifying Nested Element References with Arrows, References to Hashes, Creating an Anonymous Hash, Referencing a Named Subroutine, Indirect Object Notation

anonymous hash constructors, Creating an Anonymous Hash

arrays and, Dereferencing the Array Reference

coderefs and, Referencing a Named Subroutine

dereferencing, Simplifying Nested Element References with Arrows

dropping, Dropping Those Braces, Dropping Those Braces

hashes and, References to Hashes

indirect object syntax and, Indirect Object Notation

|| operator, Exercise (Exercise [30 min])

||= operator, Exercise (Exercise [30 min])

A

absent import lists, Selecting What to Import

abstract methods, Creating Getters and Setters More Easily

accessors, Using AUTOLOAD for Accessors, Using AUTOLOAD for Accessors, Creating Getters and Setters More Easily–Creating Getters and Setters More Easily

AUTOLOAD method and, Using AUTOLOAD for Accessors, Using AUTOLOAD for Accessors

Class::MethodMaker module, Creating Getters and Setters More Easily–Creating Getters and Setters More Easily

anonymous arrays, What if That Was the Name?, Creating an Anonymous Array Directly–Creating an Anonymous Array Directly, Creating an Anonymous Array Directly, Creating an Anonymous Hash, Selecting and Altering Complex Data

complex data and, Selecting and Altering Complex Data

creating directly, Creating an Anonymous Array Directly–Creating an Anonymous Array Directly

defined, What if That Was the Name?

hash references and, Creating an Anonymous Hash

square brackets and, Creating an Anonymous Array Directly

anonymous hash, Creating an Anonymous Hash–Creating an Anonymous Hash, Building Recursively Defined Data

creating, Creating an Anonymous Hash–Creating an Anonymous Hash

filesystem capture example, Building Recursively Defined Data

anonymous subroutines, Anonymous Subroutines, Anonymous Subroutines

API (Application Programming Interface), Adding Parameters to a Method

archiving, Writing a Distribution

arguments, What to Do with @_ (see parameters)

array reference, Taking a Reference to an Array, Taking a Reference to an Array, Dereferencing the Array Reference, Dereferencing the Array Reference, Dropping Those Braces, Dropping Those Braces, Modifying the Array, Modifying the Array, Nested Data Structures–Nested Data Structures, Nested Data Structures, Simplifying Nested Element References with Arrows, Simplifying Nested Element References with Arrows, What if That Was the Name?, Creating an Anonymous Array Directly, Creating an Anonymous Array Directly, Autovivification, Selecting and Altering Complex Data, Sorting Efficiently, The Schwartzian Transform, Nested Object Destruction, References to Filehandles

anonymous array constructors and, Creating an Anonymous Array Directly, Creating an Anonymous Array Directly

arrows and, Simplifying Nested Element References with Arrows, Simplifying Nested Element References with Arrows

blessing, Nested Object Destruction

curly braces and, Dropping Those Braces, Dropping Those Braces

dereferencing, Dereferencing the Array Reference, Dereferencing the Array Reference, Nested Data Structures, What if That Was the Name?

efficient sorting example, Sorting Efficiently

empty arrays and, Autovivification

features, Taking a Reference to an Array, Taking a Reference to an Array

hashes into, Selecting and Altering Complex Data

IO::File objects and, References to Filehandles

modifying, Modifying the Array, Modifying the Array

nested data structures, Nested Data Structures–Nested Data Structures

Schwartzian Transform, The Schwartzian Transform

ARRAY(0x1a2b3c), Taking a Reference to an Array

arrays, Packages as Namespace Separators, Introduction to References, Introduction to References, Taking a Reference to an Array, Taking a Reference to an Array, Dereferencing the Array Reference, Dereferencing the Array Reference, Dereferencing the Array Reference, Modifying the Array, Modifying the Array, Modifying the Array, Nested Data Structures, What if That Was the Name?, Creating an Anonymous Array Directly, Creating an Anonymous Array Directly

(see also anonymous arrays)

curly braces, Dereferencing the Array Reference

dereferencing and, Modifying the Array, What if That Was the Name?

modifying, Modifying the Array, Modifying the Array

nested data structures and, Nested Data Structures

ordered lists and, Introduction to References

package names and, Packages as Namespace Separators

referencing, Taking a Reference to an Array, Taking a Reference to an Array, Dereferencing the Array Reference, Dereferencing the Array Reference

scalars and, Introduction to References

scoping considerations, Creating an Anonymous Array Directly

arrows, Simplifying Nested Element References with Arrows, References to Hashes, References to Hashes, Introducing the Method Invocation Arrow, Introducing the Method Invocation Arrow, Where We Are So Far..., Indirect Object Notation

drop arrow rule, Simplifying Nested Element References with Arrows

hash references and, References to Hashes, References to Hashes

method invocation arrow, Introducing the Method Invocation Arrow, Introducing the Method Invocation Arrow, Where We Are So Far..., Indirect Object Notation

AUTOLOAD method, A Few Notes About @ISA, AUTOLOAD as a Last Resort, AUTOLOAD as a Last Resort, Using AUTOLOAD for Accessors, Using AUTOLOAD for Accessors

accessors and, Using AUTOLOAD for Accessors, Using AUTOLOAD for Accessors

functionality, AUTOLOAD as a Last Resort, AUTOLOAD as a Last Resort

inheritance and, A Few Notes About @ISA

$AUTOLOAD variable, AUTOLOAD as a Last Resort

AutoLoader core module, AUTOLOAD as a Last Resort

autovivification, Autovivification–Autovivification, Autovivification and Hashes–Autovivification and Hashes

hash references and, Autovivification and Hashes–Autovivification and Hashes

process defined, Autovivification–Autovivification

B

backstop method, More Interesting Instances, UNIVERSAL Methods

basename subroutine (File::Basename), Sample Function-Oriented Interface: File::Basename

BEGIN block, Closure Variables as Static Local Variables, What use Is Doing, What use Is Doing, Setting the Path at the Right Time, Setting the Path at the Right Time, Writing Tests with Test::More

importing subroutines, What use Is Doing

purpose, Closure Variables as Static Local Variables

setting constants, Setting the Path at the Right Time

setting paths, Setting the Path at the Right Time

use list and, What use Is Doing

use operation and, Writing Tests with Test::More

behavior, Subroutine References, Callbacks, Introducing the Method Invocation Arrow, A Horse Is a Horse, of Course of Course—or Is It?, Testing Your Objects for Good Behavior, Testing Your Objects for Good Behavior

classes and, Introducing the Method Invocation Arrow

instances and, A Horse Is a Horse, of Course of Course—or Is It?

passing as parameter, Callbacks

subroutine references and, Subroutine References

testing with isa and can methods, Testing Your Objects for Good Behavior, Testing Your Objects for Good Behavior

blessed references, Invoking an Instance Method, Invoking an Instance Method, How to Build a Horse, Making a Method Work with Either Classes or Instances, More Interesting Instances, Nested Object Destruction, Indirect Object Notation, Testing Your Objects for Good Behavior

indirect object syntax and, Indirect Object Notation

instances as, Invoking an Instance Method, Invoking an Instance Method, More Interesting Instances

isa method and, Testing Your Objects for Good Behavior

nested object destruction, Nested Object Destruction

ref operator and, Making a Method Work with Either Classes or Instances

returning, How to Build a Horse

block form, The map and grep Operators, Using map

grep operator, The map and grep Operators

map operator, Using map

C

callbacks, Callbacks, Callbacks, Closures, Closures, Closures, Returning a Subroutine from a Subroutine, Returning a Subroutine from a Subroutine

accessing variables, Closures, Returning a Subroutine from a Subroutine

find( ) function and, Closures, Closures

invoking subroutines multiple times, Returning a Subroutine from a Subroutine

subroutine references and, Callbacks, Callbacks

can method (UNIVERSAL), Testing Your Objects for Good Behavior, Testing Your Objects for Good Behavior

can_ok function (Test::More), Writing Tests with Test::More

catfile method (File::Spec), Sample Object-Oriented Interface: File::Spec

CGI module, Custom Import Routines

Changes file, Looking at the Templates

class methods, Invoking an Instance Method, How to Build a Horse, Restricting a Method to Class-Only or Instance-Only, Sample Object-Oriented Interface: File::Spec, The Differences Between OO and Non-OO Modules

building instances, How to Build a Horse

File::Spec module and, Sample Object-Oriented Interface: File::Spec

instance methods and, Invoking an Instance Method

OO modules and, The Differences Between OO and Non-OO Modules

restricting to, Restricting a Method to Class-Only or Instance-Only

class variables, Using Class Variables–Using Class Variables

Class::MethodMaker module, Creating Getters and Setters More Easily–Creating Getters and Setters More Easily

classes, Introducing the Method Invocation Arrow, A Horse Is a Horse, of Course of Course—or Is It?, Making a Method Work with Either Classes or Instances, UNIVERSAL Methods, Creating Getters and Setters More Easily, Exercise (Exercise [45 min])

accessors and, Creating Getters and Setters More Easily

defined, Introducing the Method Invocation Arrow

instances and, A Horse Is a Horse, of Course of Course—or Is It?

methods working with, Making a Method Work with Either Classes or Instances

UNIVERSAL class and, UNIVERSAL Methods

virtual methods and, Exercise (Exercise [45 min])

closure variables, Closure Variables as Static Local Variables–Closure Variables as Static Local Variables

closures, Closures–Closures, Closure Variables as Inputs, Closure Variables as Inputs, Closure Variables as Static Local Variables

functionality, Closures–Closures

lexical variables and, Closure Variables as Inputs

persistence and, Closure Variables as Static Local Variables

scope and, Closure Variables as Inputs

cmp operator, Review of Sorting

cmp_ok routine (Test::More), Writing Tests with Test::More

code, The Cure for the Common Code–Extending @INC with -I, Dereferencing the Array Reference, Introduction to Objects, Overriding the Methods, Using Modules, Essential Testing

(see also OOP)

decoupling, Dereferencing the Array Reference

reusability of, Overriding the Methods, Using Modules

testing coverage, Essential Testing

ways to share, The Cure for the Common Code–Extending @INC with -I

code references, Referencing a Named Subroutine–Closure Variables as Static Local Variables, Using AUTOLOAD for Accessors

AUTOLOAD method and, Using AUTOLOAD for Accessors

overview, Referencing a Named Subroutine–Closure Variables as Static Local Variables

collisions, namespace, The Problem of Namespace Collisions–The Problem of Namespace Collisions, Sample Object-Oriented Interface: File::Spec

comments, Exercise 2 [30 min], Writing Tests with Test::Simple

compile phase, Closure Variables as Static Local Variables, Closure Variables as Static Local Variables, A Few Notes About @ISA, AUTOLOAD as a Last Resort

AUTOLOAD and, AUTOLOAD as a Last Resort

BEGIN keyword and, Closure Variables as Static Local Variables

declarations during, Closure Variables as Static Local Variables

use base and, A Few Notes About @ISA

complex data structures, Manipulating Complex Data Structures (see data structures)

composition, inheritance versus, Additional Instance Variables in Subclasses

Comprehensive Perl Archive Network, Contributing to CPAN (see CPAN)

conditional tests, Conditional Tests

constants, setting, Setting the Path at the Right Time

constructors, Creating an Anonymous Array Directly, Creating an Anonymous Array Directly, Creating an Anonymous Hash, Creating an Anonymous Hash, Creating an Anonymous Hash, Selecting and Altering Complex Data, How to Build a Horse, Inheriting the Constructor, Inheriting the Constructor, Exporting in a Primarily OO Module

anonymous array, Creating an Anonymous Array Directly, Creating an Anonymous Array Directly, Selecting and Altering Complex Data

anonymous hash, Creating an Anonymous Hash, Creating an Anonymous Hash, Creating an Anonymous Hash

creating instances, How to Build a Horse

inheriting, Inheriting the Constructor, Inheriting the Constructor

url subroutine, Exporting in a Primarily OO Module

copyright notices, Looking at the Templates

core modules, Packages as Namespace Separators, How to Build a Horse, AUTOLOAD as a Last Resort

CPAN (Comprehensive Perl Archive Network), The Prototype Module Itself, Contributing to CPAN–Consider Writing an Article or Giving a Talk

contributing to, Contributing to CPAN–Consider Writing an Article or Giving a Talk

version numbers and, The Prototype Module Itself

current directory, require and @INC, require and @INC, Closures, Closures, Closures, Testing Things That Write to STDOUT and STDERR

find( ) function and, Closures, Closures

@INC array and, require and @INC

search path and, require and @INC, Closures

testing and, Testing Things That Write to STDOUT and STDERR

D

data, Using the Debugger to View Complex Data–Using the Debugger to View Complex Data, Viewing Complex Data with Data::Dumper, Viewing Complex Data with Data::Dumper, Storing Complex Data with Storable–Storing Complex Data with Storable, Selecting and Altering Complex Data, Selecting and Altering Complex Data, Closure Variables as Static Local Variables, Accessing the Instance Data, Exercise (Exercise [45 min])

accessing for instances, Accessing the Instance Data

selecting, Selecting and Altering Complex Data, Selecting and Altering Complex Data

storing, Storing Complex Data with Storable–Storing Complex Data with Storable, Closure Variables as Static Local Variables, Exercise (Exercise [45 min])

viewing with Data::Dumper, Viewing Complex Data with Data::Dumper, Viewing Complex Data with Data::Dumper

viewing with debugger, Using the Debugger to View Complex Data–Using the Debugger to View Complex Data

data structures, Nested Data Structures, Nested Data Structures, References and Scoping, Reference Counting and Nested Data Structures–Reference Counting and Nested Data Structures, When Reference Counting Goes Bad, When Reference Counting Goes Bad, Manipulating Complex Data Structures–Selecting and Altering Complex Data, Subroutine References, Recursively Defined Data–Displaying Recursively Defined Data

looping and, When Reference Counting Goes Bad, When Reference Counting Goes Bad

manipulating, Manipulating Complex Data Structures–Selecting and Altering Complex Data

nested, Nested Data Structures, Nested Data Structures, Reference Counting and Nested Data Structures–Reference Counting and Nested Data Structures

recursively defined, Recursively Defined Data–Displaying Recursively Defined Data

references to anonymous, References and Scoping

references to subroutines, Subroutine References

Data::Dumper module, Viewing Complex Data with Data::Dumper, Viewing Complex Data with Data::Dumper, Displaying Recursively Defined Data

daylight savings time (DST), Exercise [30 min]

dbmopen function, Exercise (Exercise [45 min])

debugging, Using the Debugger to View Complex Data–Using the Debugger to View Complex Data, Using the Debugger to View Complex Data, Viewing Complex Data with Data::Dumper, Looking at the Templates, Exercise 1 (Exercise 1 [5 min])

Changes file and, Looking at the Templates

enabling warnings during, Exercise 1 (Exercise 1 [5 min])

viewing complex data, Using the Debugger to View Complex Data–Using the Debugger to View Complex Data

x command, Using the Debugger to View Complex Data, Viewing Complex Data with Data::Dumper

delegation, Additional Instance Variables in Subclasses

dereferencing, Dereferencing the Array Reference, Dereferencing the Array Reference, Nested Data Structures, References to Hashes, What if That Was the Name?, Referencing a Named Subroutine, Referencing a Named Subroutine, Closures

array references, Dereferencing the Array Reference, Dereferencing the Array Reference, Nested Data Structures, What if That Was the Name?

coderefs, Referencing a Named Subroutine, Referencing a Named Subroutine

hash references, References to Hashes

lexical variables and, Closures

DESTROY method, Object Destruction, Object Destruction, Nested Object Destruction, Beating a Dead Horse, Beating a Dead Horse

inheritance and, Beating a Dead Horse, Beating a Dead Horse

nested objects, Nested Object Destruction

purpose, Object Destruction, Object Destruction

destructors, Nested Object Destruction–Nested Object Destruction, Weakening the Argument, References to Filehandles

class variables and, Weakening the Argument

IO::File objects and, References to Filehandles

nested objects example, Nested Object Destruction–Nested Object Destruction

direct object syntax, Indirect Object Notation, Indirect Object Notation

directories, Extending @INC with PERL5LIB, Building Recursively Defined Data, What the Test Harness Does

represented as hashes, Building Recursively Defined Data

separating with colon, Extending @INC with PERL5LIB

t files and, What the Test Harness Does

dirname subroutine (File::Basename), Sample Function-Oriented Interface: File::Basename

distributions, Starting with h2xs, Looking at the Templates–Looking at the Templates, Looking at the Templates, The Prototype Module Itself–The Prototype Module Itself, The Prototype Module Itself, The Prototype Module Itself, The Prototype Module Itself, Embedded Documentation–Embedded Documentation, Embedded Documentation–Embedded Documentation, Controlling the Distribution with Makefile.PL–Controlling the Distribution with Makefile.PL, Alternate Installation Locations (PREFIX=...), Trivial make test–Trivial make test, Trivial make dist, Trivial make dist, Essential Testing, Writing Tests with Test::Simple, Writing Tests with Test::Simple, Writing Tests with Test::More–Writing Tests with Test::More, Preparing Your Distribution, Preparing Your Distribution, Preparing Your Distribution, Uploading Your Distribution, Uploading Your Distribution, Announcing the Module

alternate installation locations, Alternate Installation Locations (PREFIX=...)

announcing CPAN modules, Announcing the Module

copyrights and licensing, Looking at the Templates

embedded documentation, Embedded Documentation–Embedded Documentation

Exporter module, The Prototype Module Itself

h2xs tool, Starting with h2xs

make dist and, Trivial make dist, Trivial make dist

Makefile.PL, Controlling the Distribution with Makefile.PL–Controlling the Distribution with Makefile.PL

modules within, The Prototype Module Itself–The Prototype Module Itself

POD format, Embedded Documentation–Embedded Documentation

preparing, Preparing Your Distribution, Preparing Your Distribution

qw( ) lists, The Prototype Module Itself

template files, Looking at the Templates–Looking at the Templates

Test::More module, Writing Tests with Test::More–Writing Tests with Test::More

Test::Simple module, Writing Tests with Test::Simple, Writing Tests with Test::Simple

testing, Trivial make test–Trivial make test, Essential Testing

uploading to CPAN, Uploading Your Distribution, Uploading Your Distribution

version numbers, The Prototype Module Itself, Preparing Your Distribution

do operator, Using do–Using do

documentation, Writing a Distribution, Embedded Documentation–Embedded Documentation, Essential Testing

distribution considerations, Writing a Distribution

embedded for distribution, Embedded Documentation–Embedded Documentation

testing and, Essential Testing

drop arrow rule, Simplifying Nested Element References with Arrows

Dumper subroutine, Viewing Complex Data with Data::Dumper

E

empty import lists, Selecting What to Import

encapsulation, object, Don’t Look Inside the Box

END blocks, Object Destruction

_ _END_ _ marker, Embedded Documentation

eval function, Inserting Code with eval, Inserting Code with eval

@EXPORT variable, @EXPORT and @EXPORT_OK, @EXPORT and @EXPORT_OK, The Prototype Module Itself

Exporter module, Importing with Exporter, Importing with Exporter, @EXPORT and @EXPORT_OK, Exporting in a Primarily OO Module, The Prototype Module Itself

distributions, The Prototype Module Itself

importing with, Importing with Exporter, Importing with Exporter, Exporting in a Primarily OO Module

package variables, @EXPORT and @EXPORT_OK

exporting, The Differences Between OO and Non-OO Modules, Exporting in a Primarily OO Module, The Prototype Module Itself, The Prototype Module Itself

OO modules and, The Differences Between OO and Non-OO Modules, Exporting in a Primarily OO Module, The Prototype Module Itself

symbols, The Prototype Module Itself

export_fail method (Exporter), Exporting in a Primarily OO Module

@EXPORT_OK variable, @EXPORT and @EXPORT_OK, @EXPORT and @EXPORT_OK, The Prototype Module Itself

export_to_level method (Exporter), Exporting in a Primarily OO Module

expression form, The map and grep Operators, Using map

grep operator, The map and grep Operators

map operator, Using map

extending, Beating a Dead Horse, Beating a Dead Horse, Additional Instance Variables in Subclasses, Using Class Variables

class variables, Using Class Variables

subroutines, Additional Instance Variables in Subclasses

superclass methods, Beating a Dead Horse, Beating a Dead Horse

ExtUtils::MakeMaker module, Controlling the Distribution with Makefile.PL

F

File::Basename module, Sample Function-Oriented Interface: File::Basename, Sample Function-Oriented Interface: File::Basename, Importing with Exporter

File::Find module, Callbacks, Closures–Closures, Exercise [30 min]

features, Callbacks, Closures–Closures

returning coderefs, Exercise [30 min]

File::Spec module, Sample Object-Oriented Interface: File::Spec

filehandles, Packages as Namespace Separators, Object Destruction, Nested Object Destruction, References to Filehandles–References to Filehandles, Testing Things That Write to STDOUT and STDERR, Exercise (Exercise [30 min]), Exercise (Exercise [30 min])

instance variables, Nested Object Destruction

ok function (Test::More) and, Testing Things That Write to STDOUT and STDERR

package names and, Packages as Namespace Separators

|| operator and, Exercise (Exercise [30 min])

references to, References to Filehandles–References to Filehandles

storing in a hash, Exercise (Exercise [30 min])

temporary files, Object Destruction

fileparse subroutine (File::Basename), Sample Function-Oriented Interface: File::Basename, Importing with Exporter

files, Closures–Closures, Exercise [30 min], Sample Function-Oriented Interface: File::Basename, Sample Object-Oriented Interface: File::Spec, Looking at the Templates

distribution templates, Looking at the Templates

File::Spec module, Sample Object-Oriented Interface: File::Spec

find subroutine, Closures–Closures

finding timestamps, Exercise [30 min]

parsing specifications, Sample Function-Oriented Interface: File::Basename

filesystems, Callbacks, Callbacks, Building Recursively Defined Data–Building Recursively Defined Data

capturing information about, Building Recursively Defined Data–Building Recursively Defined Data

walking through hierarchy, Callbacks, Callbacks

find subroutine (File::Find), Callbacks, Closures–Closures

friend classes, Additional Instance Variables in Subclasses, Creating Getters and Setters More Easily

G

garbage collection, When Reference Counting Goes Bad

getters, Don’t Look Inside the Box, Faster Getters and Setters, Getters That Double as Setters, Getters That Double as Setters, Using AUTOLOAD for Accessors, Using AUTOLOAD for Accessors, Creating Getters and Setters More Easily–Creating Getters and Setters More Easily

AUTOLOAD method and, Using AUTOLOAD for Accessors, Using AUTOLOAD for Accessors

creating easily, Creating Getters and Setters More Easily–Creating Getters and Setters More Easily

doubling as setters, Getters That Double as Setters, Getters That Double as Setters

encapsulation and, Don’t Look Inside the Box

optimizing, Faster Getters and Setters

glob operator, Exercise 1 [15 min], Using AUTOLOAD for Accessors, References to Filehandles

global variables, Packages and Lexicals, Closure Variables as Inputs, Object Destruction

data destruction and, Object Destruction

package variables as, Packages and Lexicals

scope and, Closure Variables as Inputs

grep operator, Performing the Same Task on Many Arrays, The map and grep Operators–The map and grep Operators, The map and grep Operators, Applying a Bit of Indirection, Selecting and Altering Complex Data, Selecting and Altering Complex Data, Sorting with Indices, References to Filehandles, References to Filehandles

(see also Schwartzian Transform)

filehandles and, References to Filehandles, References to Filehandles

functionality, The map and grep Operators–The map and grep Operators

indices and, Sorting with Indices

indirection and, Applying a Bit of Indirection

scalar context and, Performing the Same Task on Many Arrays, The map and grep Operators

selecting complex data, Selecting and Altering Complex Data

H

h2xs tool, Starting with h2xs, Controlling the Distribution with Makefile.PL, More Complex Tests (Multiple Test Scripts)

distributions and, Starting with h2xs

Makefile.PL and, Controlling the Distribution with Makefile.PL

multiple test scripts and, More Complex Tests (Multiple Test Scripts)

hash reference, References to Hashes–References to Hashes, References to Hashes, Exercise 2 [30 min], Creating an Anonymous Hash, Autovivification and Hashes–Autovivification and Hashes, Using the Debugger to View Complex Data, Using the Debugger to View Complex Data, Using the Debugger to View Complex Data, Viewing Complex Data with Data::Dumper, Building Recursively Defined Data, Building Recursively Defined Data, Object Destruction

anonymous hash constructors, Creating an Anonymous Hash

autovivification and, Autovivification and Hashes–Autovivification and Hashes

Data::Dumper example, Viewing Complex Data with Data::Dumper

debugging example, Using the Debugger to View Complex Data, Using the Debugger to View Complex Data, Using the Debugger to View Complex Data

dereferencing, References to Hashes

features, References to Hashes–References to Hashes

filesystem capture example, Building Recursively Defined Data

object destruction, Object Destruction

as parameters, Exercise 2 [30 min]

as return values, Building Recursively Defined Data

HASH(0x1a2b3c), References to Hashes

hashes, Packages as Namespace Separators, Introduction to References, Taking a Reference to an Array, Using map, Selecting and Altering Complex Data, Building Recursively Defined Data, Building Recursively Defined Data, More Interesting Instances, Exercise (Exercise [30 min])

(see also anonymous hash)

directories as, Building Recursively Defined Data

instances and, More Interesting Instances

map operator and, Using map

package names and, Packages as Namespace Separators

references and, Taking a Reference to an Array, Selecting and Altering Complex Data

scalars and, Introduction to References

storing filehandles, Exercise (Exercise [30 min])

hexadecimal memory address, Taking a Reference to an Array, References to Hashes

I

importing, Selecting What to Import, What use Is Doing, What use Is Doing, Importing with Exporter, Importing with Exporter, @EXPORT and @EXPORT_OK, Custom Import Routines, Custom Import Routines

-nosticky option, Custom Import Routines

custom routines, Custom Import Routines

Exporter module and, Importing with Exporter, Importing with Exporter

File::Basename module and, Selecting What to Import

subroutines, What use Is Doing, @EXPORT and @EXPORT_OK

use operation and, What use Is Doing

@INC array, require and @INC–Extending @INC with -I, Setting the Path at the Right Time

require operator and, require and @INC–Extending @INC with -I

use operation and, Setting the Path at the Right Time

indices, sorting with, Sorting with Indices, Sorting with Indices

indirect object notation, Indirect Object Notation–Indirect Object Notation

indirection, Applying a Bit of Indirection–Applying a Bit of Indirection, Sorting with Indices

applying, Applying a Bit of Indirection–Applying a Bit of Indirection

sorting indices, Sorting with Indices

inheritance, Calling a Second Method to Simplify Things, Calling a Second Method to Simplify Things, A Few Notes About @ISA, Overriding the Methods, Inheriting the Constructor, Inheriting the Constructor, Beating a Dead Horse, Beating a Dead Horse, Additional Instance Variables in Subclasses, Testing Your Objects for Good Behavior, Multiple Inheritance

@ISA variable and, A Few Notes About @ISA

code reusability through, Overriding the Methods

composition versus, Additional Instance Variables in Subclasses

constructors and, Inheriting the Constructor, Inheriting the Constructor

DESTROY method and, Beating a Dead Horse, Beating a Dead Horse

isa method testing, Testing Your Objects for Good Behavior

method invocation and, Calling a Second Method to Simplify Things, Calling a Second Method to Simplify Things

multiple inheritance, Multiple Inheritance

installation (of modules), Writing a Distribution, Alternate Installation Locations (PREFIX=...), Using the Alternate Library Location

alternate library locations, Using the Alternate Library Location

alternate locations, Alternate Installation Locations (PREFIX=...)

distribution considerations, Writing a Distribution

instance methods, Invoking an Instance Method, Invoking an Instance Method, Invoking an Instance Method, Adding Parameters to a Method, Adding Parameters to a Method, Restricting a Method to Class-Only or Instance-Only, A More Typical Object-Oriented Module: Math::BigInt, The Differences Between OO and Non-OO Modules

APIs and, Adding Parameters to a Method

class methods and, Invoking an Instance Method

invoking, Invoking an Instance Method, Invoking an Instance Method

Math::BigInt module, A More Typical Object-Oriented Module: Math::BigInt

OO modules and, The Differences Between OO and Non-OO Modules

parameters and, Adding Parameters to a Method

restricting to, Restricting a Method to Class-Only or Instance-Only

instance variables, A Horse Is a Horse, of Course of Course—or Is It?, More Interesting Instances, Object Destruction, Nested Object Destruction, Additional Instance Variables in Subclasses, Additional Instance Variables in Subclasses

defined, A Horse Is a Horse, of Course of Course—or Is It?

filehandles as, Nested Object Destruction

hash keys, More Interesting Instances

object destruction and, Object Destruction

in subclasses, Additional Instance Variables in Subclasses, Additional Instance Variables in Subclasses

instances, A Horse Is a Horse, of Course of Course—or Is It?, A Horse Is a Horse, of Course of Course—or Is It?, Invoking an Instance Method, Invoking an Instance Method, How to Build a Horse, Making a Method Work with Either Classes or Instances, More Interesting Instances, Testing Your Objects for Good Behavior, Creating Getters and Setters More Easily

accessors and, Creating Getters and Setters More Easily

blessed references and, Invoking an Instance Method, Invoking an Instance Method

building, How to Build a Horse

defined, A Horse Is a Horse, of Course of Course—or Is It?, A Horse Is a Horse, of Course of Course—or Is It?

hashes and, More Interesting Instances

isa method testing, Testing Your Objects for Good Behavior

methods working with, Making a Method Work with Either Classes or Instances

interfaces, Creating Getters and Setters More Easily, Sample Function-Oriented Interface: File::Basename, Sample Function-Oriented Interface: File::Basename, Sample Object-Oriented Interface: File::Spec, Writing a Distribution, The Prototype Module Itself

distribution considerations, Writing a Distribution

File::Basename module, Sample Function-Oriented Interface: File::Basename, Sample Function-Oriented Interface: File::Basename

File::Spec module, Sample Object-Oriented Interface: File::Spec

maintenance considerations, Creating Getters and Setters More Easily

version numbers and, The Prototype Module Itself

IO::File class, References to Filehandles, References to Filehandles

is function (Test::More), Writing Tests with Test::More, Testing Things That Write to STDOUT and STDERR

@ISA variable, A Few Notes About @ISA, A Few Notes About @ISA, UNIVERSAL Methods, Multiple Inheritance

features, A Few Notes About @ISA, A Few Notes About @ISA

inheritance hierarchies and, UNIVERSAL Methods

multiple inheritance, Multiple Inheritance

isa method (UNIVERSAL), Testing Your Objects for Good Behavior, Testing Your Objects for Good Behavior

isa_ok function (Test::More), Writing Tests with Test::More

isnt function (Test::More), Writing Tests with Test::More

iteration versus recursion, Recursively Defined Data

K

key/value pairs, Creating an Anonymous Hash

L

lexical variables, Using do, Packages and Lexicals, Packages and Lexicals, More than One Reference to Data, Closures, Closures, Returning a Subroutine from a Subroutine, Closure Variables as Inputs, Closure Variables as Static Local Variables, A Few Notes About @ISA, Object Destruction

@ISA and, A Few Notes About @ISA

closures and, Closures, Closure Variables as Inputs

data destruction and, Object Destruction

defined, Using do

packages and, Packages and Lexicals, Packages and Lexicals

reference longevity, More than One Reference to Data

subroutine references, Closures, Returning a Subroutine from a Subroutine, Closure Variables as Static Local Variables

libraries, Using require, require and @INC, Alternate Installation Locations (PREFIX=...), Using the Alternate Library Location

alternate installation locations, Alternate Installation Locations (PREFIX=...), Using the Alternate Library Location

loading only once, Using require

search path for, require and @INC

licensing, Looking at the Templates

like function (Test::More), Writing Tests with Test::More

lists, Selecting What to Import, Selecting What to Import, The Prototype Module Itself, Exercise 2 (Exercise 2 [30 min])

absent import lists, Selecting What to Import

qw( ) list, Selecting What to Import, The Prototype Module Itself

sorted list, Exercise 2 (Exercise 2 [30 min])

looping (code structure), Using the Debugger to View Complex Data, Closure Variables as Static Local Variables

looping (data structure), When Reference Counting Goes Bad, When Reference Counting Goes Bad

M

maintenance considerations, Creating Getters and Setters More Easily

make dist, Trivial make dist, Trivial make dist

make install, Trivial make install

make test, Trivial make test–Trivial make test, Essential Testing, Writing Tests with Test::Simple

Makefile.PL, Controlling the Distribution with Makefile.PL–Controlling the Distribution with Makefile.PL, Alternate Installation Locations (PREFIX=...), Trivial make test, Using the Alternate Library Location, What the Test Harness Does, What the Test Harness Does, Writing Tests with Test::More, Preparing Your Distribution

controlling distribution, Controlling the Distribution with Makefile.PL–Controlling the Distribution with Makefile.PL

PREFIX=option, Alternate Installation Locations (PREFIX=...), Using the Alternate Library Location

test harness, Trivial make test, What the Test Harness Does, What the Test Harness Does, Writing Tests with Test::More

testing and, Preparing Your Distribution

MANIFEST file, Looking at the Templates, Looking at the Templates, Preparing Your Distribution

map operator, The map and grep Operators–Using map, Using map, Applying a Bit of Indirection, Selecting and Altering Complex Data, Selecting and Altering Complex Data

(see also Schwartzian Transform)

functionality, The map and grep Operators–Using map

indirection and, Applying a Bit of Indirection

scalar context, Using map

selecting complex data, Selecting and Altering Complex Data

Math::BigInt module, A More Typical Object-Oriented Module: Math::BigInt, A More Typical Object-Oriented Module: Math::BigInt

member variables, A Horse Is a Horse, of Course of Course—or Is It?, More Interesting Instances

memory addresses, Taking a Reference to an Array, References to Hashes

memory management, When Reference Counting Goes Bad–When Reference Counting Goes Bad, Weakening the Argument

meta-variables, Using Class Variables

methods, Introducing the Method Invocation Arrow, Introducing the Method Invocation Arrow, The Extra Parameter of Method Invocation, The Extra Parameter of Method Invocation, Calling a Second Method to Simplify Things, Calling a Second Method to Simplify Things, Overriding the Methods–Overriding the Methods, Where We Are So Far..., Invoking an Instance Method, Invoking an Instance Method, Making a Method Work with Either Classes or Instances, Adding Parameters to a Method, Adding Parameters to a Method, Adding Parameters to a Method, Getters That Double as Setters, Restricting a Method to Class-Only or Instance-Only, Beating a Dead Horse, Beating a Dead Horse, Indirect Object Notation, UNIVERSAL Methods, Creating Getters and Setters More Easily

(see also class methods instance methods)

abstract methods, Creating Getters and Setters More Easily

getters doubling as setters, Getters That Double as Setters

inheritance and, Calling a Second Method to Simplify Things, Calling a Second Method to Simplify Things

instances and, Invoking an Instance Method, Invoking an Instance Method

invocation arrow, Introducing the Method Invocation Arrow, Introducing the Method Invocation Arrow, Where We Are So Far..., Indirect Object Notation

overriding, Overriding the Methods–Overriding the Methods

parameters and, The Extra Parameter of Method Invocation, The Extra Parameter of Method Invocation, Adding Parameters to a Method, Adding Parameters to a Method

restricting, Restricting a Method to Class-Only or Instance-Only

superclasses, Beating a Dead Horse, Beating a Dead Horse

UNIVERSAL class and, UNIVERSAL Methods

working with classes, Making a Method Work with Either Classes or Instances

modules, Packages as Namespace Separators, How to Build a Horse, AUTOLOAD as a Last Resort, Using Modules–Custom Import Routines, Using Modules, Starting with h2xs, The Prototype Module Itself–The Prototype Module Itself, Announcing the Module

(see also packages)

announcing, Announcing the Module

core modules, Packages as Namespace Separators, How to Build a Horse, AUTOLOAD as a Last Resort

distributions and, Starting with h2xs, The Prototype Module Itself–The Prototype Module Itself

overview, Using Modules–Custom Import Routines

my variables, Using do, Scope of a Package Directive

N

namespaces, The Problem of Namespace Collisions–The Problem of Namespace Collisions, Packages as Namespace Separators–Packages as Namespace Separators, Sample Object-Oriented Interface: File::Spec

packages as separators, Packages as Namespace Separators–Packages as Namespace Separators

problems with collisions, The Problem of Namespace Collisions–The Problem of Namespace Collisions, Sample Object-Oriented Interface: File::Spec

nested entities, Nested Data Structures, Nested Data Structures, Simplifying Nested Element References with Arrows, Reference Counting and Nested Data Structures–Reference Counting and Nested Data Structures, Nested Object Destruction–Nested Object Destruction

data structures, Nested Data Structures, Nested Data Structures, Reference Counting and Nested Data Structures–Reference Counting and Nested Data Structures

element references, Simplifying Nested Element References with Arrows

object destruction, Nested Object Destruction–Nested Object Destruction

new method, How to Build a Horse, Indirect Object Notation, A More Typical Object-Oriented Module: Math::BigInt

creating objects, How to Build a Horse

indirect object notation, Indirect Object Notation

Math::BigInt module, A More Typical Object-Oriented Module: Math::BigInt

numbers, Review of Sorting, Review of Sorting, Writing Tests with Test::More

sorting, Review of Sorting, Review of Sorting

testing equality, Writing Tests with Test::More

O

object-oriented programming, Introduction to Objects (see OOP)

objects, A Horse Is a Horse, of Course of Course—or Is It?, A Horse Is a Horse, of Course of Course—or Is It?, How to Build a Horse, More Interesting Instances, More Interesting Instances, Don’t Look Inside the Box, Object Destruction–Weakening the Argument, Testing Your Objects for Good Behavior, Testing Your Objects for Good Behavior, References to Filehandles

bless operator and, A Horse Is a Horse, of Course of Course—or Is It?

as blessed references, More Interesting Instances

creating, How to Build a Horse

destruction of, Object Destruction–Weakening the Argument

encapsulation of, Don’t Look Inside the Box

filehandles and, References to Filehandles

instances and, A Horse Is a Horse, of Course of Course—or Is It?

structure considerations, More Interesting Instances

testing with isa and can methods, Testing Your Objects for Good Behavior, Testing Your Objects for Good Behavior

ok function (Test::Simple), Writing Tests with Test::Simple, Testing Things That Write to STDOUT and STDERR

OO (object-oriented) modules, The Differences Between OO and Non-OO Modules, Exporting in a Primarily OO Module, The Prototype Module Itself, Writing Tests with Test::More

exporting, The Prototype Module Itself

exporting and, Exporting in a Primarily OO Module

non-OO versus, The Differences Between OO and Non-OO Modules

Test::More module, Writing Tests with Test::More

OOP (object-oriented programming), Introduction to Objects–Where We Are So Far..., Sample Object-Oriented Interface: File::Spec, The Differences Between OO and Non-OO Modules, Exercise 2 (Exercise 2 [40 min])

File::Spec module, Sample Object-Oriented Interface: File::Spec

inheritance structures and, Exercise 2 (Exercise 2 [40 min])

overview, Introduction to Objects–Where We Are So Far...

versus non-OOP, The Differences Between OO and Non-OO Modules

ordered lists, Introduction to References

our variables, A Few Notes About @ISA

overriding, Overriding the Methods–Overriding the Methods, Beating a Dead Horse, Beating a Dead Horse, UNIVERSAL Methods

methods, Overriding the Methods–Overriding the Methods

superclass methods, Beating a Dead Horse, Beating a Dead Horse

UNIVERSAL class methods, UNIVERSAL Methods

P

packages, Packages as Namespace Separators–Packages as Namespace Separators, Packages as Namespace Separators, Packages as Namespace Separators, Scope of a Package Directive, Scope of a Package Directive, Packages and Lexicals, Packages and Lexicals, Packages and Lexicals, Closure Variables as Inputs, Introducing the Method Invocation Arrow, A Few Notes About @ISA, A Few Notes About @ISA, Using Modules

(see also modules)

@ISA variable and, A Few Notes About @ISA, A Few Notes About @ISA

global variables, Packages and Lexicals, Closure Variables as Inputs

lexicals and, Packages and Lexicals, Packages and Lexicals

main program in, Packages as Namespace Separators

as namespace separators, Packages as Namespace Separators–Packages as Namespace Separators

naming considerations, Packages as Namespace Separators, Introducing the Method Invocation Arrow

scope of directives, Scope of a Package Directive, Scope of a Package Directive

parameters, Exercise 2 [30 min], Returning a Subroutine from a Subroutine, Returning a Subroutine from a Subroutine, The Extra Parameter of Method Invocation, The Extra Parameter of Method Invocation, Calling a Second Method to Simplify Things, What to Do with @_, What to Do with @_, Invoking an Instance Method, Invoking an Instance Method, How to Build a Horse, Adding Parameters to a Method, Adding Parameters to a Method, Getting Your Deposit Back, Additional Instance Variables in Subclasses

(see also return values)

@_, What to Do with @_

adding to methods, Adding Parameters to a Method, Adding Parameters to a Method

callbacks and, Returning a Subroutine from a Subroutine, Returning a Subroutine from a Subroutine

hash references as, Exercise 2 [30 min]

instance methods and, Invoking an Instance Method

instances as, Invoking an Instance Method

method invocation and, The Extra Parameter of Method Invocation, The Extra Parameter of Method Invocation

passing to superclasses, Additional Instance Variables in Subclasses

returning updated values, Getting Your Deposit Back

shifting, Calling a Second Method to Simplify Things, What to Do with @_

parent-child relationships, Weakening the Argument

parsing, The Cure for the Common Code, Performing the Same Task on Many Arrays, Sample Function-Oriented Interface: File::Basename

file specifications, Sample Function-Oriented Interface: File::Basename

shifting style, The Cure for the Common Code, Performing the Same Task on Many Arrays

passing by reference, Taking a Reference to an Array (see references)

PATH environment variable, require and @INC

paths, searching for installed modules/libraries, Setting the Path at the Right Time, Setting the Path at the Right Time

PAUSE (Perl Authors Upload Server) ID, Getting Prepared, Uploading Your Distribution

perl command, require and @INC, Extending @INC with -I, Using the Debugger to View Complex Data, Indirect Object Notation, Controlling the Distribution with Makefile.PL, Alternate Installation Locations (PREFIX=...), Using the Alternate Library Location, Using the Alternate Library Location, Using the Alternate Library Location, Exercise 1 (Exercise 1 [5 min])

-d option, Using the Debugger to View Complex Data

-I option, Extending @INC with -I, Using the Alternate Library Location

-M option, Using the Alternate Library Location

-V command line option, require and @INC

-V:make, Controlling the Distribution with Makefile.PL

-w option, Indirect Object Notation, Exercise 1 (Exercise 1 [5 min])

PREFIX= option (Makefile.PL), Alternate Installation Locations (PREFIX=...), Using the Alternate Library Location

perl-packrats mailing list, The Comprehensive Perl Archive Network

PERL5LIB environment variable, Extending @INC with PERL5LIB

.pl (Perl Library) extension, Using do

.plx (Perl Executable) extension, Using do

.pm (Perl Module) extension, What use Is Doing

POD format, Embedded Documentation–Embedded Documentation

prefixes, explicit, The Problem of Namespace Collisions

PREREQ_PM setting (Makefiles), Controlling the Distribution with Makefile.PL

programs, The Cure for the Common Code–Extending @INC with -I, Dereferencing the Array Reference, Autovivification, Subroutine References, Closure Variables as Static Local Variables, Closure Variables as Static Local Variables, Introduction to Objects, Object Destruction

(see also OOP)

behaviors of, Subroutine References

compile phase, Closure Variables as Static Local Variables

object destruction and, Object Destruction

run phase, Closure Variables as Static Local Variables

sharing code, The Cure for the Common Code–Extending @INC with -I

whitespace, Dereferencing the Array Reference, Autovivification

properties, instances and, A Horse Is a Horse, of Course of Course—or Is It?

push function, Extending @INC

Q

qw( ) list, Selecting What to Import, The Prototype Module Itself

R

README file, Looking at the Templates, Looking at the Templates, Preparing Your Distribution

recursively defined data, Building Recursively Defined Data–Displaying Recursively Defined Data

ref operator, Making a Method Work with Either Classes or Instances, Restricting a Method to Class-Only or Instance-Only

reference counting, More than One Reference to Data, Reference Counting and Nested Data Structures–Reference Counting and Nested Data Structures, When Reference Counting Goes Bad–When Reference Counting Goes Bad, When Reference Counting Goes Bad, Returning a Subroutine from a Subroutine, Returning a Subroutine from a Subroutine, Weakening the Argument

closures and, Returning a Subroutine from a Subroutine

defined, More than One Reference to Data

garbage collection and, When Reference Counting Goes Bad

memory management and, When Reference Counting Goes Bad–When Reference Counting Goes Bad

nested data structures and, Reference Counting and Nested Data Structures–Reference Counting and Nested Data Structures

subroutine reference example, Returning a Subroutine from a Subroutine

weak references and, Weakening the Argument

references, Introduction to References–References to Hashes, Taking a Reference to an Array, References and Scoping–Autovivification and Hashes, Referencing a Named Subroutine–Closure Variables as Static Local Variables, Recursively Defined Data, A Horse Is a Horse, of Course of Course—or Is It?, A Horse Is a Horse, of Course of Course—or Is It?, A Horse Is a Horse, of Course of Course—or Is It?, How to Build a Horse, Inheriting the Constructor, More Interesting Instances, Object Destruction, Weakening the Argument–Weakening the Argument, Weakening the Argument, References to Filehandles–References to Filehandles, Exercise 1 (Exercise 1 [5 min])

(see also array reference blessed references dereferencing hash reference)

bless operator, A Horse Is a Horse, of Course of Course—or Is It?

destruction and, Weakening the Argument

to filehandles, References to Filehandles–References to Filehandles

hierarchical data and, Recursively Defined Data

instances and, A Horse Is a Horse, of Course of Course—or Is It?, A Horse Is a Horse, of Course of Course—or Is It?, Inheriting the Constructor, More Interesting Instances

named subroutines, Referencing a Named Subroutine–Closure Variables as Static Local Variables

object destruction and, Object Destruction

overview, Introduction to References–References to Hashes

return values, How to Build a Horse

as scalars, Exercise 1 (Exercise 1 [5 min])

scoping and, References and Scoping–Autovivification and Hashes

weak references, Weakening the Argument–Weakening the Argument

require operator, Using require, Using require, Using require, require and @INC–Extending @INC with -I, What use Is Doing, What use Is Doing

@INC and, require and @INC–Extending @INC with -I

functionality, Using require, Using require

syntax errors and, Using require

use operation and, What use Is Doing, What use Is Doing

require_version method (Exporter), Exporting in a Primarily OO Module

return values, Returning a Subroutine from a Subroutine, Exercise [30 min], Building Recursively Defined Data, Building Recursively Defined Data, How to Build a Horse, How to Build a Horse, Getting Your Deposit Back, What use Is Doing

(see also parameters)

bless operator and, How to Build a Horse

coderefs as, Exercise [30 min]

hash references, Building Recursively Defined Data

required files, What use Is Doing

subroutine references, Returning a Subroutine from a Subroutine

undef example, Building Recursively Defined Data

updated parameters, Getting Your Deposit Back

run phase, Closure Variables as Static Local Variables, Closure Variables as Static Local Variables

BEGIN keyword and, Closure Variables as Static Local Variables

storage allocation, Closure Variables as Static Local Variables

S

s command (debugger), Using the Debugger to View Complex Data

scalars, Packages as Namespace Separators, Introduction to References, Taking a Reference to an Array, Creating an Anonymous Hash, Referencing a Named Subroutine, Closures, Indirect Object Notation, Testing Your Objects for Good Behavior, References to Filehandles, Exercise 1 (Exercise 1 [5 min])

anonymous, Closures

curly braces and, Referencing a Named Subroutine

filehandles and, References to Filehandles

hash references and, Creating an Anonymous Hash

indirect object syntax, Indirect Object Notation

isa method and, Testing Your Objects for Good Behavior

package names and, Packages as Namespace Separators

references and, Taking a Reference to an Array, Exercise 1 (Exercise 1 [5 min])

single values and, Introduction to References

Schwartzian Transform, The Schwartzian Transform, Exercise 3 [10 min], Exercise 2 (Exercise 2 [15 min])

dictionary order, Exercise 3 [10 min]

performance, Exercise 2 (Exercise 2 [15 min])

sorting and, The Schwartzian Transform

scope, Using do, References and Scoping–Autovivification and Hashes, Closure Variables as Inputs

do operator and, Using do

global variables and, Closure Variables as Inputs

references and, References and Scoping–Autovivification and Hashes

scripts, Alternate Installation Locations (PREFIX=...), More Complex Tests (Multiple Test Scripts)

alternate installation locations, Alternate Installation Locations (PREFIX=...)

complex tests, More Complex Tests (Multiple Test Scripts)

search path, require and @INC, Closures

SelfLoader core module, AUTOLOAD as a Last Resort

setters, Getting Your Deposit Back–Getting Your Deposit Back, Don’t Look Inside the Box, Faster Getters and Setters, Getters That Double as Setters, Getters That Double as Setters, Getters That Double as Setters, Getters That Double as Setters, Using AUTOLOAD for Accessors, Using AUTOLOAD for Accessors, Creating Getters and Setters More Easily–Creating Getters and Setters More Easily

AUTOLOAD method and, Using AUTOLOAD for Accessors, Using AUTOLOAD for Accessors

creating, Getting Your Deposit Back–Getting Your Deposit Back, Creating Getters and Setters More Easily–Creating Getters and Setters More Easily

encapsulation and, Don’t Look Inside the Box

getters doubling as, Getters That Double as Setters, Getters That Double as Setters

optimizing, Faster Getters and Setters, Getters That Double as Setters

restricting methods, Getters That Double as Setters

shifting, The Cure for the Common Code, Performing the Same Task on Many Arrays, Performing the Same Task on Many Arrays, Dereferencing the Array Reference, Closure Variables as Inputs, Calling a Second Method to Simplify Things, What to Do with @_

@_ array, Performing the Same Task on Many Arrays

argument parsing, The Cure for the Common Code, Performing the Same Task on Many Arrays

arguments, Calling a Second Method to Simplify Things, What to Do with @_

closure variables, Closure Variables as Inputs

example eliminating, Dereferencing the Array Reference

smoke tests, Testing on Multiple Platforms

sorting, Review of Sorting, Review of Sorting, Review of Sorting, Sorting with Indices, Sorting with Indices, Sorting Efficiently–Sorting Efficiently, The Schwartzian Transform, Exercise 1 [15 min], Exercise 3 [10 min], Exercise 2 (Exercise 2 [30 min])

dictionary order, Exercise 3 [10 min]

efficient, Sorting Efficiently–Sorting Efficiently

glob operator, Exercise 1 [15 min]

with indices, Sorting with Indices, Sorting with Indices

review of, Review of Sorting, Review of Sorting

Schwartzian Transform, The Schwartzian Transform

sort blocks, Review of Sorting

sorted list, Exercise 2 (Exercise 2 [30 min])

spaceship operator, Review of Sorting

sqrt function, Essential Testing

static local variables, Closure Variables as Static Local Variables–Closure Variables as Static Local Variables

STDERR filehandle, Testing Things That Write to STDOUT and STDERR

STDOUT filehandle, Testing Things That Write to STDOUT and STDERR

Storable module, Storing Complex Data with Storable–Storing Complex Data with Storable

storing data, Storing Complex Data with Storable–Storing Complex Data with Storable, Closure Variables as Static Local Variables, Exercise (Exercise [45 min])

strings, Writing Tests with Test::More (see text strings)

subclasses, Additional Instance Variables in Subclasses, Additional Instance Variables in Subclasses, Creating Getters and Setters More Easily

abstract methods and, Creating Getters and Setters More Easily

instance variables in, Additional Instance Variables in Subclasses, Additional Instance Variables in Subclasses

subroutine references, Referencing a Named Subroutine–Closure Variables as Static Local Variables

subroutines, Inserting Code with eval, Packages as Namespace Separators, Referencing a Named Subroutine–Referencing a Named Subroutine, Closures, Closure Variables as Static Local Variables, Additional Instance Variables in Subclasses, Testing Your Objects for Good Behavior, Using Modules, What use Is Doing, @EXPORT and @EXPORT_OK, Custom Import Routines

(see also closures)

custom import routines, Custom Import Routines

extending, Additional Instance Variables in Subclasses

importing, What use Is Doing, @EXPORT and @EXPORT_OK

isa called as, Testing Your Objects for Good Behavior

modules and, Using Modules

out of scope variables and, Closure Variables as Static Local Variables

package names and, Packages as Namespace Separators

referencing, Referencing a Named Subroutine–Referencing a Named Subroutine

syntax errors and, Inserting Code with eval

SUPER pseudo-class, The SUPER Way of Doing Things

superclasses, The SUPER Way of Doing Things, Beating a Dead Horse, Beating a Dead Horse, Additional Instance Variables in Subclasses

symbols, Importing with Exporter, The Prototype Module Itself

syntax errors, Inserting Code with eval, Using require

system performance, Creating Getters and Setters More Easily

T

t directory, What the Test Harness Does

“take a reference to” operator, Taking a Reference to an Array, References to Hashes, Referencing a Named Subroutine

template files, Looking at the Templates–Looking at the Templates

temporary files, Object Destruction, Nested Object Destruction, Nested Object Destruction, Testing Things That Write to STDOUT and STDERR

data destruction and, Object Destruction, Nested Object Destruction, Nested Object Destruction

STDOUT and, Testing Things That Write to STDOUT and STDERR

Test::More module, Writing Tests with Test::More–Writing Tests with Test::More, Testing Things That Write to STDOUT and STDERR

Test::Simple module, Writing Tests with Test::Simple, Writing Tests with Test::Simple

testing, Testing Your Objects for Good Behavior, Testing Your Objects for Good Behavior, Writing a Distribution, Trivial make test–Trivial make test, Trivial make test, Essential Testing, Essential Testing, What the Test Harness Does, What the Test Harness Does, Writing Tests with Test::Simple, Writing Tests with Test::More, Writing Tests with Test::More, Writing Tests with Test::More, Writing Tests with Test::More, Conditional Tests, More Complex Tests (Multiple Test Scripts), Testing Things That Write to STDOUT and STDERR, Preparing Your Distribution, Testing on Multiple Platforms

code coverage, Essential Testing

conditional tests, Conditional Tests

distributions and, Writing a Distribution, Trivial make test–Trivial make test

inequality, Writing Tests with Test::More

isa and can methods, Testing Your Objects for Good Behavior, Testing Your Objects for Good Behavior

Makefile.PL and, Preparing Your Distribution

multiple test scripts, More Complex Tests (Multiple Test Scripts)

numeric equality, Writing Tests with Test::More

pound-sign comments and, Writing Tests with Test::Simple

smoke tests, Testing on Multiple Platforms

sqrt function, Essential Testing

test harness, Trivial make test, What the Test Harness Does, What the Test Harness Does, Writing Tests with Test::More

use operation, Writing Tests with Test::More

writing to STDOUT and STDERR, Testing Things That Write to STDOUT and STDERR

testing expression (of map or grep), The map and grep Operators, Using map

TEST_VERBOSE option (make test), Writing Tests with Test::Simple

text strings, Review of Sorting, Review of Sorting, Making a Method Work with Either Classes or Instances, Writing Tests with Test::More

cmp operator, Review of Sorting

like function, Writing Tests with Test::More

ref operator and, Making a Method Work with Either Classes or Instances

sorting, Review of Sorting

timestamps, Exercise [30 min]

TODO blocks, Conditional Tests

$TODO variable, Conditional Tests

U

undef (value), Autovivification, Closure Variables as Static Local Variables, Building Recursively Defined Data, Making a Method Work with Either Classes or Instances, Weakening the Argument

autovivification and, Autovivification

filesystem capture example, Building Recursively Defined Data

ref operator and, Making a Method Work with Either Classes or Instances

variables with value of, Closure Variables as Static Local Variables

weak references and, Weakening the Argument

unimport method (Exporter), Exporting in a Primarily OO Module

UNIVERSAL class, A Few Notes About @ISA, UNIVERSAL Methods, Testing Your Objects for Good Behavior, Testing Your Objects for Good Behavior

inheritance and, A Few Notes About @ISA

purpose of, UNIVERSAL Methods

utility methods, Testing Your Objects for Good Behavior, Testing Your Objects for Good Behavior

unshift function, Extending @INC, Setting the Path at the Right Time

URI::URL module, Exporting in a Primarily OO Module

URIs (universal resource identifiers), Exporting in a Primarily OO Module

url subroutine (URI::URL), Exporting in a Primarily OO Module

use base, A Few Notes About @ISA

use CGI, Custom Import Routines

use lib, Setting the Path at the Right Time, Setting the Path at the Right Time, Using the Alternate Library Location

use operation, What use Is Doing–What use Is Doing, The Prototype Module Itself, Writing Tests with Test::More, Writing Tests with Test::More

use strict, If We Could Talk to the Animals..., A Few Notes About @ISA

V

variables, Using do, Scope of a Package Directive, Packages and Lexicals, Taking a Reference to an Array, What if That Was the Name?, What if That Was the Name?, Subroutine References, Closures, Closures, Closures, Returning a Subroutine from a Subroutine, Returning a Subroutine from a Subroutine, Returning a Subroutine from a Subroutine, Closure Variables as Inputs, Closure Variables as Inputs, Closure Variables as Static Local Variables, Closure Variables as Static Local Variables–Closure Variables as Static Local Variables, Closure Variables as Static Local Variables–Closure Variables as Static Local Variables, Introducing the Method Invocation Arrow, A Few Notes About @ISA, A Horse Is a Horse, of Course of Course—or Is It?, A Horse Is a Horse, of Course of Course—or Is It?, A Horse Is a Horse, of Course of Course—or Is It?, More Interesting Instances, Object Destruction, Using Class Variables–Using Class Variables, Using Class Variables, References to Filehandles, Using Modules

(see also instance variables lexical variables scalars)

bless operator, A Horse Is a Horse, of Course of Course—or Is It?

callbacks and, Closures, Returning a Subroutine from a Subroutine

class variables, Using Class Variables–Using Class Variables

closure variables, Closure Variables as Static Local Variables–Closure Variables as Static Local Variables

filehandles and, References to Filehandles

global variables, Packages and Lexicals, Closure Variables as Inputs, Object Destruction

member variables, A Horse Is a Horse, of Course of Course—or Is It?, More Interesting Instances

memory addresses of, Taking a Reference to an Array

meta-variables, Using Class Variables

modules and, Using Modules

my variables, Using do, Scope of a Package Directive

our variables, A Few Notes About @ISA

out of scope, Closures, Closures, Returning a Subroutine from a Subroutine, Returning a Subroutine from a Subroutine, Closure Variables as Inputs, Closure Variables as Static Local Variables

package names, Introducing the Method Invocation Arrow

reference removal and, What if That Was the Name?, What if That Was the Name?

as repository of values, Subroutine References

static local, Closure Variables as Static Local Variables–Closure Variables as Static Local Variables

version numbers, The Prototype Module Itself, Preparing Your Distribution

$VERSION variable, Trivial make dist

viewing data, Using the Debugger to View Complex Data–Using the Debugger to View Complex Data, Viewing Complex Data with Data::Dumper, Viewing Complex Data with Data::Dumper

Data::Dumper, Viewing Complex Data with Data::Dumper, Viewing Complex Data with Data::Dumper

with debugger, Using the Debugger to View Complex Data–Using the Debugger to View Complex Data

void context, Getting Your Deposit Back, Getting Your Deposit Back, Getting Your Deposit Back

W

wantarray function, Getting Your Deposit Back, Getting Your Deposit Back

warnings, enabling, Using require, Exercise 1 (Exercise 1 [5 min])

weak references, Weakening the Argument–Weakening the Argument

WeakRef module, Weakening the Argument

whitespace, Dereferencing the Array Reference, Autovivification

working directory, Closures (see current directory)

WriteMakefile subroutine (ExtUtils::MakeMaker), Controlling the Distribution with Makefile.PL

writing distributions, Writing a Distribution–Using the Alternate Library Location

X

x command (debugger), Using the Debugger to View Complex Data, Viewing Complex Data with Data::Dumper