7. The Standard Perl Library

This chapter describes the collection of Perl code that comes along with the Perl distribution. If you use this library and then share your program with others, they will not have to take special steps to execute the program, because the same library is available to Perl programs everywhere.

You'll save some time if you make the effort to get familiar with the standard library. There's no point in reinventing the wheel. You should be aware, however, that the library contains a wide range of material. While some modules may be extremely helpful, others may be completely irrelevant to your needs. For example, some are useful only if you are creating extensions to Perl. We offer below a rough classification of the library modules to aid you in browsing.

First, however, let's untangle some terminology:

package

A package is a simple namespace management device, allowing two different parts of a Perl program to have a (different) variable named $fred . These namespaces are managed with the package declaration, described in Chapter 5, Packages, Modules, and Object Classes .

library

A library is a set of subroutines for a particular purpose. Often the library declares itself a separate package so that related variables and subroutines can be kept together, and so that they won't interfere with other variables in your program. Generally, a library is placed in a separate file, often ending in " .pl ", and then pulled into the main program via require . (This mechanism has largely been superseded by the module mechanism, so nowadays we often use the term "library" to talk about the whole system of modules that come with Perl. See the title of this chapter, for instance.)

module

A module is a library that conforms to specific conventions, allowing the file to be brought in with a use directive at compile time. Module filenames end in " .pm ", because the use directive insists on that. (It also translates the subpackage delimiter :: to whatever your subdirectory delimiter is; it is / on UNIX.) Chapter 5 describes Perl modules in greater detail.

pragma

A pragma is a module that affects the compilation phase of your program as well as the execution phase. Think of them as hints to the compiler. Unlike modules, pragmas often (but not always) limit the scope of their effects to the innermost enclosing block of your program. The names of pragmas are by convention all lowercase.

For easy reference, this chapter is arranged alphabetically. If you wish to look something up by functional grouping, Tables 7-1 through 7-11 display an (admittedly arbitrary) listing of the modules and pragmas described in this chapter.

Table 7.1: General Programming: Miscellaneous

Module	Function
Benchmark	Check and compare running times of code
Config	Access Perl configuration information
Env	Import environment variables
English	Use English or awk names for punctuation variables
Getopt::Long	Extended processing of command-line options
Getopt::Std	Process single-character switches with switch clustering
lib	Manipulate @INC at compile time
Shell	Run shell commands transparently within Perl
strict	Restrict unsafe constructs
Symbol	Generate anonymous globs; qualify variable names
subs	Predeclare subroutine names
vars	Predeclare global variable names

Table 7.2: General Programming: Error Handling and Logging

Module	Function
Carp	Generate error messages
diagnostics	Force verbose warning diagnostics
sigtrap	Enable stack backtrace on unexpected signals
Sys::Syslog	Perl interface to UNIX syslog (3) calls

Table 7.3: General Programming: File Access and Handling

Module	Function
Cwd	Get pathname of current working directory
DirHandle	Supply object methods for directory handles
File::Basename	Parse file specifications
File::CheckTree	Run many tests on a collection of files
File::Copy	Copy files or filehandles
File::Find	Traverse a file tree
File::Path	Create or remove a series of directories
FileCache	Keep more files open than the system permits
FileHandle	Supply object methods for filehandles
SelectSaver	Save and restore selected filehandle

Table 7.4: General Programming: Text Processing and Screen Interfaces

Module	Function
Pod::Text	Convert POD data to formatted ASCII text
Search::Dict	Search for key in dictionary file
Term::Cap	Terminal capabilities interface
Term::Complete	Word completion module
Text::Abbrev	Create an abbreviation table from a list
Text::ParseWords	Parse text into a list of tokens
Text::Soundex	The Soundex Algorithm described by Knuth
Text::Tabs	Expand and unexpand tabs
Text::Wrap	Wrap text into a paragraph

Table 7.5: Database Interfaces

Module	Function
AnyDBM_File	Provide framework for multiple DBMs
DB_File	Tied access to Berkeley DB
GDBM_File	Tied access to GDBM library
NDBM_File	Tied access to NDBM files
ODBM_File	Tied access to ODBM files
SDBM_File	Tied access to SDBM files

Table 7.6: Mathematics

Module	Function
integer	Do arithmetic in integer instead of double
Math::BigFloat	Arbitrary-length floating-point math package
Math::BigInt	Arbitrary-length integer math package
Math::Complex	Complex numbers package

Table 7.7: Networking and Interprocess Communication

Module	Function
IPC::Open2	Open a process for both reading and writing
IPC::Open3	Open a process for reading, writing, and error handling
Net::Ping	Check whether a host is online
Socket	Load the C socket.h defines and structure manipulators
Sys::Hostname	Try every conceivable way to get hostname

Table 7.8: Time and Locale

Module	Function
Time::Local	Efficiently compute time from local and GMT time
I18N::Collate	Compare 8-bit scalar data according to the current locale

Table 7.9: For Developers: Autoloading and Dynamic Loading

Module	Function
AutoLoader	Load functions only on demand
AutoSplit	Split a module for autoloading
Devel::SelfStubber	Generate stubs for a SelfLoading module
DynaLoader	Automatic dynamic loading of Perl modules
SelfLoader	Load functions only on demand

Table 7.10: For Developers: Language Extensions and Platform Development Support

Module	Function
ExtUtils::Install	Install files from here to there
ExtUtils::Liblist	Determine libraries to use and how to use them
ExtUtils::MakeMaker	Create a Makefile for a Perl extension
ExtUtils::Manifest	Utilities to write and check a MANIFEST file
ExtUtils::Miniperl	Write the C code for perlmain.c
ExtUtils::Mkbootstrap	Make a bootstrap file for use by DynaLoader
ExtUtils::Mksymlists	Write linker option files for dynamic extension
ExtUtils::MM_OS2	Methods to override UNIX behavior in ExtUtils::MakeMaker
ExtUtils::MM_Unix	Methods used by ExtUtils::MakeMaker
ExtUtils::MM_VMS	Methods to override UNIX behavior in ExtUtils::MakeMaker
Fcntl	Load the C fcntl.h defines
POSIX	Interface to IEEE Std 1003.1
Safe	Create safe namespaces for evaluating Perl code
Test::Harness	Run Perl standard test scripts with statistics

Table 7.11: For Developers: Object-Oriented Programming Support

Module	Function
Exporter	Default import method for modules
overload	Overload Perl's mathematical operations
Tie::Hash	Base class definitions for tied hashes
Tie::Scalar	Base class definitions for tied scalars
Tie::StdHash	Base class definitions for tied hashes
Tie::StdScalar	Base class definitions for tied scalars
Tie::SubstrHash	Fixed-table-size, fixed-key-length hashing