Standard Modules

Listings by Type
Benchmark
Carp
CGI
CGI::Carp
Class::Struct
Config
CPAN
Cwd
Data::Dumper
DB_File
Dumpvalue
English
Errno
Exporter
Fatal
Fcntl
File::Basename
File::Compare
File::Copy
File::Find
File::Glob
File::Spec
File::stat
File::Temp
FileHandle
Getopt::Long
Getopt::Std
IO::Socket
IPC::Open2
IPC::Open3
Math::BigInt
Math::Complex
Math::Trig
Net::hostent
POSIX
Safe
Socket
Symbol
Sys::Hostname
Sys::Syslog
Term::Cap
Text::Wrap
Time::Local
Time::localtime
User::grent
User::pwent

The previous version of this tutorial included comprehensive, definitive coverage for all modules that were part of the standard Perl distribution. But if we did that again now, you'd pay twice what you're paying for this tutorial, not to mention what you'd have to pay the chiropractor after trying to carry the tutorial home. Over the last few years, more and more modules have come bundled standard; we're up to around two hundred of them right now. Some of these, such as CGI, have remarkably extensive documentation in their own right. And if you're using ActiveState's distribution of Perl, your standard library is even more luxed out.

So instead, we provide a complete listing of the standard modules, sorted by type, along with a brief description of what each module does. Then we cherry pick a few of our favorite modules by providing examples of typical uses, followed by a short description of how they work, just to give you a taste of using them. The descriptions are suggestive rather than comprehensive, and virtually all the modules have features beyond those shown. However, complete documentation for all standard modules is included with every Perl distribution, so you can just look up the details on your own system using the perldoc program, your system's man(1) command, or your favorite browser. See the section "Online Documentation" in the Preface. Ask your Local Expert if you can't find the docs, because they're almost certainly installed somewhere on your system. Even if they're not, you can always read the pod docs directly from the modules themselves, because all module docs come embedded in their corresponding module (pm) files, and pod was designed to be somewhat readable. (Unlike, say, HTML.)

Listings by Type

Normal module names begin with an uppercase letter. Lowercase names indicate pragmas that you'll find documented in "Pragmatic Modules", rather than in this chapter.

Data Types

These modules extend Perl's type system (or lack thereof) in various ways.

Module	Description
`Class::Struct`	Create `struct`-like Perl object classes
`constant`	Declare constant scalars and lists
`integer`	Force Perl to do arithmetic with integers instead of floating point
`Math::BigFloat`	Calculate with arbitrary length floating-point math
`Math::BigInt`	Calculate with arbitrary length integer math
`Math::Complex`	Calculate with complex numbers and associated mathematical functions
`Math::Trig`	Load many trigonometric and related functions
`overload`	Overload Perl operators on objects
`Symbol`	Manipulate Perl symbol tables and generate anonymous typeglobs
`Time::Local`	Efficiently compute epoch time given `localtime` or `gmtime`

String Processing, Language Text Processing, Parsing, and Searching

These modules do things with (or to) text.

Module	Description
`Search::Dict`	Use a binary search for a string in a sorted text file
`Text::Abbrev`	Create an abbreviation table from a list
`Text::ParseWords`	Parse text into a list of tokens or an array of arrays
`Text::Soundex`	Use Knuth's Soundex algorithm
`Text::Tabs`	Expand or unexpand tabs like expand (1) and unexpand (1)
`Text::Wrap`	Wrap lines to form simple paragraphs

Option, Argument, Parameter, and Configuration File Processing

These modules process your command line.

Module	Description
`Getopt::Long`	Process extended command-line options in long form (`--xxx`)
`Getopt::Std`	Process single-character switches with switch clustering (`-xyz`)

Filenames, Filesystems, and File Locking

These modules provide cross-platform methods of file access.

Module	Description
`Cwd`	Get the pathname of the current working directory
`File::Basename`	Portably parse a pathname into directory, basename, and extension components
`File::CheckTree`	Run many file test checks on a set of directory trees
`File::Compare`	Portably compare contents of filenames or filehandles
`File::Copy`	Portably copy filenames or filehandles or move filenames
`File::DosGlob`	Do Microsoft-style fileglobbing
`File::Find`	Traverse a file tree like find(1)
`File::Glob`	Use Unix-style fileglobbing
`File::Path`	Portably create or remove a series of directories
`File::Spec`	Use portable filename operations (object-oriented interface)
`File::Spec::Functions`	Use portable filename operations (functional interface)
`File::Spec::Mac`	Use filename operations for Mac OS files
`File::Spec::OS2`	Use filename operations for OS/2 files
`File::Spec::Unix`	Use filename operations for Unix files
`File::Spec::VMS`	Use filename operations for VMS files
`File::Spec::Win32`	Use filename operations for Microsoft files
`File::stat`	Override built-in `stat` and `lstat` functions with a method interface

Filehandle, Directory Handle, and Stream I/O Utilities

These modules provide object-oriented file, directory, and IPC access.

Module	Description
`DirHandle`	Use object methods for directory handles
`FileCache`	Keep more files concurrently open for output than your system permits
`FileHandle`	Use object methods for filehandles
`IO`	Provide a frontend to load all of `IO::Dir`, `IO::File`, `IO::Handle`, `IO::Pipe`, `IO::Seekable`, and `IO::Socket`
`IO::Dir`	Use object methods for directory handles
`IO::File`	Use file-related object methods for filehandles
`IO::Handle`	Use generic object methods for filehandles
`IO::Pipe`	Use object methods for pipes
`IO::Poll`	Provide an object interface to poll(2) syscall
`IO::Seekable`	Use object methods for seekable I/O objects
`IO::Select`	Use a convenient OO interface to the select(2) syscall
`SelectSaver`	Save and restore selected filehandle

Internationalization and Locale

These modules help you perform Un-American Activities.

Module	Description
`bytes`	Enforce old byte-oriented semantics
`charnames`	Define character names used in `N{`name`}` escapes in string literals
`I18N::Collate`	Compare 8-bit scalar data according to current locale (deprecated)
`locale`	Use or avoid POSIX locales for built-in operations
`utf8`	Turn on UTF-8 and Unicode support explicitly

Operating System Interfaces

These modules tweak your interface to the operating system.

Module	Description
`Fcntl`	Load the C library's fcntl.h definitions as Perl constants
`filetest`	Control the file test operators (`-r`, `-w`, etc.) for nontraditional filesystems
`open`	Set default disciplines for `open` function calls
`POSIX`	Use the Perl interface to POSIX 1003.1
`Shell`	Run shell commands transparently within Perl
`sigtrap`	Enable simple signal handling
`Sys::Hostname`	Portably try every conceivable way to determine the current hostname
`Sys::Syslog`	Use the C library's syslog(3) functions
`Time::gmtime`	Override the built-in `gmtime` function with a method interface
`Time::localtime`	Override the built-in `localtime` function with a method interface
`Time::tm`	Provide the internal object used by `Time::gmtime` and `Time::localtime`
`User::grent`	Override built-in `getgr*` functions with a method interface
`User::pwent`	Override built-in `getpw*` functions with a method interface

Networking and Interprocess Communication

These modules provide abstract interfaces around the basic interfaces we wrote about in "Interprocess Communication".

Module	Description
`IO::Socket`	Use a generic object interface to socket communications
`IO::Socket::INET`	Use an object interface for Internet-domain sockets
`IO::Socket::UNIX`	Use an object interface for Unix-domain (local) sockets
`IPC::Msg`	Use object methods for working with System V messages (SysV Msg IPC object class)
`IPC::Open2`	Open a process for simultaneous reading and writing
`IPC::Open3`	Open a process for reading, writing, and error handling
`IPC::Semaphore`	Use object methods for System V semaphores
`IPC::SysV`	Define constants for all System V IPC mechanisms
`Net::hostent`	Override built-in `gethost*` functions with a method interface
`Net::netent`	Override built-in `getnet*` functions with a method interface
`Net::Ping`	Check a remote host for reachability
`Net::protoent`	Override built-in `getproto*` functions with a method interface
`Net::servent`	Override built-in `getserv*` functions with a method interface
`Socket`	Load the C library socket.h definitions and structure manipulators

World Wide Web

These modules interface to the WWW. You may have heard of it.

Module	Description
`CGI`	Access CGI forms and powerful automated HTML generation
`CGI::Apache`	Make your CGI script work under the Perl-Apache API
`CGI::Carp`	Write to the httpd(8) (or other) CGI error log
`CGI::Cookie`	Set and get HTTP cookies
`CGI::Fast`	Use the Fast CGI protocol
`CGI::Pretty`	Produce nicely formatted HTML code
`CGI::Push`	Do server-push CGI scripting

DBM Interfaces

These modules load various database management libraries.

Module	Description
`AnyDBM_File`	Provide a framework for multiple DBM libraries
`DB_File`	Provide tied access to the db(3) library (version 1.x Berkeley DB)
`GDBM_File`	Provide tied access to the gdbm(3) library
`NDBM_File`	Provide tied access to the ndbm(3) library
`SDBM_File`	Provide tied access to SDBM (simple DBM) files

User Interfaces

These modules provide a decent OS CLI I/O API, ASAP.

Module	Description
`Term::Cap`	Use the termcap(3) library
`Term::Complete`	Do programmable command completion on word lists
`Term::ReadLine`	Use any of several readline packages

Authentication, Security, and Encryption

These modules work with sandboxes.

Module	Description
`Opcode`	Enable or disable named opcodes when compiling Perl code for use with the `Safe` module
`ops`	Restrict unsafe operations when compiling
`Safe`	Compile and execute code in restricted compartments

Perl Language Extensions and Internals

(Not to be confused with Intentions and Externals.)

Module	Description
`attributes`	Get or set subroutine or variable attributes
`attrs`	Get or set subroutine or variable attributes (obsolete)
`base`	Establish inheritance of base class at compile time
`Data::Dumper`	Serialize Perl data structures
`DB`	Access the Perl debugger's experimental API
`Devel::DProf`	Profile a Perl program's execution
`Devel::Peek`	Load data debugging tools for XS developers
`diagnostics`	Force verbose warnings and suppress duplicates
`Dumpvalue`	Provide screen dump of data
`English`	Use longer variable names for built-in punctuation variables
`Env`	Access environment variables in `%ENV` as regular scalars
`Errno`	Load the C library's errno.h definitions and tie the `%!` variable
`Fatal`	Replace built-ins with versions that raise exceptions on failure
`fields`	Declare compile-time verified access to a class's data attributes
`less`	Request less of something from Perl (unimplemented)
`re`	Alter default regular expression behavior
`strict`	Restrict sloppy constructs
`subs`	Predeclare the subroutine names in current the package
`vars`	Predeclare global variables (obsolete--see `our` in "Functions")

Convenient Classes

These modules provide base classes and other conveniences.

Module	Description
`Tie::Array`	Provide a base class for tied arrays
`Tie::Handle`	Provide base class definitions for tied handles
`Tie::Hash`	Provide base class definitions for tied hashes
`Tie::RefHash`	Provide references as hash keys
`Tie::Scalar`	Provide base class definitions for tied scalars
`Tie::SubstrHash`	Hash a fixed-size table with a fixed-length key
`UNIVERSAL`	Provide a base class for all classes (blessed references)

Warnings and Exceptions

What to do when things go rwong.

Module	Description
`Carp`	Provide routines that `warn` and `die` from the perspective of the caller
`warnings`	Control warnings within the lexical scope

Documentation Support

And there's an awful lot of documentation to support.

Module	Description
`Pod::Checker`	Check pod documents for syntax errors (used by podchecker(1))
`Pod::Functions`	List built-in functions by type
`Pod::Html`	Convert pod files to HTML (used by pod2html(1))
`Pod::InputObjects`	Manage documentation support
`Pod::Man`	Convert pod to troff(1) format for the man(1) system (used by pod2man(1))
`Pod::Parser`	Provide a base class for creating pod filters and translators
`Pod::Select`	Extract selected sections of pod from input (used by podselect(1))
`Pod::Text`	Convert pod data to formatted ASCII text (used by pod2text(1))
`Pod::Text::Color`	Convert pod data to formatted ASCII text with ANSI color escapes
`Pod::Text::Termcap`	Convert pod data to ASCII text with terminal-specific escapes
`Pod::Usage`	Print a usage message derived from embedded pod documentation

Module Installation Support

These modules help other modules jump through various hoops.

Module	Description
`AutoLoader`	Load subroutines only on demand
`AutoSplit`	Split a package for autoloading
`autouse`	Postpone module loading until a function is used from that module
`blib`	Use the library from `MakeMaker`'s uninstalled version of an extension
`Config`	Access Perl configuration information
`CPAN`	Query, download, and build Perl modules from CPAN sites
`Devel::SelfStubber`	Generate stubs for a module using `SelfLoader`
`DynaLoader`	Dynamically load C or C++ libraries as Perl extensions
`Exporter`	Implement default import method for traditional modules
`ExtUtils::Command`	Provide utilities to replace common external commands in Makefile
`ExtUtils::Embed`	Provide utilities for embedding Perl in C or C++ programs
`ExtUtils::Install`	Install files into the system's Perl library
`ExtUtils::Installed`	Manage inventory of installed modules
`ExtUtils::Liblist`	Determine which libraries to use and how to use them
`ExtUtils::MakeMaker`	Create a Makefile for a Perl extension
`ExtUtils::Manifest`	Load tools to write and check a MANIFEST file
`ExtUtils::Miniperl`	Write the C code for perlmain.c
`ExtUtils::Mkbootstrap`	Create a bootstrap file for use by `DynaLoader`
`ExtUtils::Mksymlists`	Write linker options files for dynamic extension
`ExtUtils::MM_Cygwin`	Override Unix behavior methods in `ExtUtils::MakeMaker`
`ExtUtils::MM_OS2`	Override Unix behavior methods in `ExtUtils::MakeMaker`
`ExtUtils::MM_Unix`	Provide methods used by `ExtUtils::MakeMaker`
`ExtUtils::MM_VMS`	Override Unix behavior methods in `ExtUtils::MakeMaker`
`ExtUtils::MM_Win32`	Override Unix behavior methods in `ExtUtils::MakeMaker`
`ExtUtils::Packlist`	Manage packlist files
`ExtUtils::testlib`	Add blib/* directories to `@INC`
`FindBin`	Locate installation directory of the Perl program that is running
`lib`	Manipulate `@INC` at compile time
`SelfLoader`	Load functions only on demand
`XSLoader`	Dynamically load C or C++ libraries as Perl extensions

Development Support

These modules are for timing and testing, to see how much faster and cleaner your code doesn't run anymore.

Module	Description
`Benchmark`	Compare running times of alternate code versions
`Test`	Use a simple framework for writing test scripts
`Test::Harness`	Run standard test scripts with statistics

Perl Compiler and Code Generator

These modules support various backend code generators for Perl.

Module	Description
`B`	Load Perl code generators (a.k.a. the "Perl compiler")
`B::Asmdata`	Provide autogenerated data about Perl ops to produce bytecode
`B::Assembler`	Assemble Perl bytecode
`B::Bblock`	Walk basic blocks in the syntax tree
`B::Bytecode`	Use the Perl compiler's bytecode backend
`B::C`	Use the Perl compiler's C translation backend
`B::CC`	Use the Perl compiler's optimized C translation backend
`B::Debug`	Walk the Perl syntax tree, printing debug info about ops
`B::Deparse`	Use the Perl compiler backend to reproduce Perl code
`B::Disassembler`	Disassemble Perl bytecode
`B::Lint`	Catch dubious constructs
`B::Showlex`	Show lexical variables used in functions or files
`B::Stash`	Show what stashes are loaded
`B::Terse`	Walk the Perl syntax tree, printing terse info about ops
`B::Xref`	Generate cross-reference reports for Perl programs
`ByteLoader`	Load byte-compiled Perl code
`O`	Provide a generic interface to Perl compiler backends

Microsoft-Related Modules

If you got the Perl distribution for Microsoft systems from ActiveState, you already have the following Microsoft-only modules included for you. If you just grabbed the standard source distribution (maybe you want to build it under the Cygwin Unix-emulation environment) but you're running on Wintel, you can get all of these modules from CPAN.

Module	Description
`Win32::ChangeNotify`	Monitor events related to files and directories
`Win32::Console`	Use Win32 console and character mode functions
`Win32::Event`	Use Win32 event objects from Perl
`Win32::EventLog`	Process Win32 event logs from Perl
`Win32::File`	Manage file attributes in Perl
`Win32::FileSecurity`	Manage FileSecurity Discretionary Access Control Lists in Perl
`Win32::IPC`	Load the base class for Win32 synchronization objects
`Win32::Internet`	Access WININET.DLL functions
`Win32::Mutex`	Use Win32 mutex objects from Perl
`Win32::NetAdmin`	Manage network groups and users in Perl
`Win32::NetResource`	Manage network resources in Perl
`Win32::ODBC`	Use ODBC Extension for Win32
`Win32::OLE`	Use OLE automation extensions
`Win32::OLE::Const`	Extract constant definitions from TypeLib
`Win32::OLE::Enum`	Use OLE Automation Collection Objects
`Win32::OLE::NLS`	Use OLE National Language Support
`Win32::OLE::Variant`	Create and modify OLE VARIANT variables
`Win32::PerfLib`	Access the Windows Performance Counter
`Win32::Process`	Create and manipulate processes
`Win32::Semaphore`	Use Win32 semaphore objects
`Win32::Service`	Manage system services
`Win32::Sound`	Play with Windows sounds
`Win32::TieRegistry`	Mung the registry
`Win32API::File`	Access low-level Win32 system API calls for files and directories
`Win32API::Net`	Manage Windows LanManager accounts
`Win32API::Registry`	Access low-level Win32 system API calls from WINREG.H