Beginners	Built-In Functions	Advanced	CGI Applications
Introduction Syntax Operators Variables Scope Data Types Flow Control Subroutines RegEx	Arithmetic Strings Arrays Hashes Date/Time Printing	Files Directories Databases Reports RegEx Exceptions System Calls Modules One Liners Reference	Unix Forms CGI Cookies

Perl Modules
Perl allows you to put subroutines into separate files (called modules) and to reference those files within a Perl script, making the subroutines contained within the modules available to the script.

Better yet, Perl ships with other 300 modules, covering a very wide range of topics. I highly recommend that you review the available modules and make use of the free code that has been extensively tested by the Perl community.

Also, be sure to visit the website CPAN, the Comprehensive Perl Archive Network. CPAN contains over 12,000 modules freely available to Perl programmers.

Module Keywords Summary
There are just a few keywords to know in order to make use of modules.

Importing Modules	use
Module Management	no, package, our

Add Modules to Scripts
To add a module to a Perl script, you must import the module with the keyword 'use' as shown in the following code example.

     use mymodule;            # content of mymodule.pm is imported
     use mymodule.pl;         # content of mymodule.pm is imported

If no module filename extension is provided, the default extension of .pm will be used. Modules installed with Perl all use the file extension .pm.

Once a module is imported into a script, the subroutines found within the module can be used/called just as though they were contained within the script.

Module File Format
A module can be as simple as a standard script file, as in this next example which contains nothing but two subroutines and a line of code to return an exit code of 1 (true).

     sub lowercase {
     $x = shift;
     return lc($x);
     }
     sub mymessage {
     print "Gary Beene";
     }
     1;

Be aware that any code in the module which is outside subroutines will be executed when the module is imported - such as the last line which is purposely included because Perl requires that a module return an exit code of 1.

While the simple script file above can be used as a module, most modules contain significantly more information. For a more complete description of creating modules, use perldoc.

Using a Module
If the example code above was placed in a file called 'mymodule.pm', then the following program would execute each of the two subroutines found within the module.

     #!/usr/bin/perl
     use mymodule;            
     mymessage;                # prints 'Gary Beene'
     print lowercase('DOG');   # prints 'dog'

Module Naming
In this simple example, the Perl script and the module would be placed in the same directory and the module name is simply 'mymodule.pm'.

However, in a typical Perl installation, Perl modules are found in the 'c:\perl\lib' folder, beneath which are found folders that contain the module *.pm files.

Modules are typically named with the syntax Module::Name, where the folders beneath 'c:\perl\lib' are the Module and the files themselves are the Name (less the extension).

In some cases, the folder structure is several levels deep, such as the installed module File::Spec::Win32, which refers to a module Win32.pm found within the c:\perl\lib\file\spec folder.

Referencing Module Variables and Subroutines
The File::Find module uses a variable called $dir. To use $dir in a script it can be referenced as $File::Find::dir.

As long as the 'use' reference to the module occurs at the start of a Perl script subroutines can be called by simply using the subroutine name (as in the example script above). However, just as Perl allows the used of an '&' to signify subroutines further down in the script, subroutines in modules can be referenced early also by using the '\&' nomenclature, as in '\&mysub'.

Modules Functions/Keywords Reference
Here's a quick reference of the available module functions/keywords, in alphabetical order.

Unless otherwise noted, these functions operate on $_ by default.

• use - load a module at compile time

      no Module VERSION LIST
      

• no - unimport a module

      no Module VERSION LIST
  
      no allows the disabling of a pragma, limited to the code block in which
      the no is called. 
      

• package - declare a separate global namespace

      package NAMESPACE
  
      package allows compartmentalization of code to prevent the overlapping
      use of global variables, particularly when multiple programmers are 
      working on parts of a project. See perldoc for more information.
      

• our - declare and assign a package variable

      our EXPR
      
      Use of our lets you use module global variables without qualifying
      them with package names.
      

Modules Distributed with Perl
The list of 300+ modules shipped with Perl is provided at the bottom of this page. Of those, here are some of the more commonly used modules.

1. Cwd - get pathname of current working directory
2. Fatal - replace functions with equivalents which succeed or die
3. File::Basename - parse file paths into directory, filename and suffix.
4. File::Copy - copy files or filehandles
5. File::Spec - portably perform operations on file names
6. Image::Size - read image files sizes (CPAN)
7. Net::SMTP - send email using SMTP
8. POSIX - advanced math functions
9. Sys::Hostname - get PC hostname
10. Text::Wrap - line wrapping to form simple paragraphs
11. Time::Local - efficiently compute time from local and GMT time

Module Documentation
To learn how to use a particular module contained in the Perl distribution, enter the following at a command line.

     perldoc Module::Name

Pragmatic Modules (Pragmas)
Pragmas are special modules that come with Perl and generally provide compiler directives.

The following pragmas are distributed with Perl and are documented within Perldoc. For information on a specific pragma, enter the following at a command line.

     perldoc pragmaname

1. attributes - Get/set subroutine or variable attributes
2. attrs - Set/get attributes of a subroutine (deprecated)
3. autouse - Postpone load of modules until a function is used
4. base - Establish IS-A relationship with base classes at compile time
5. bigint - Transparent BigInteger support for Perl
6. bignum - Transparent BigNumber support for Perl
7. bigrat - Transparent BigNumber/BigRational support for Perl
8. blib - Use MakeMaker's uninstalled version of a package
9. bytes - Force byte semantics rather than character semantics
10. charnames - Define character names for \N{named} string literal escapes
11. constant - Declare constants
12. diagnostics - Produce verbose warning diagnostics
13. encoding - Allows you to write your script in non-ascii or non-utf8
14. fields - Compile-time class fields
15. filetest - Control the filetest permission operators
16. if - use a Perl module if a condition holds
17. integer - Use integer arithmetic instead of floating point
18. less - Request less of something from the compiler
19. lib - Manipulate @INC at compile time
20. locale - Use and avoid POSIX locales for built-in operations
21. open - Set default PerlIO layers for input and output
22. ops - Restrict unsafe operations when compiling
23. overload - Package for overloading Perl operations
24. re - Alter regular expression behaviour
25. sigtrap - Enable simple signal handling
26. sort - Control sort() behaviour
27. strict - Restrict unsafe constructs
28. subs - Predeclare sub names
29. threads - Perl extension allowing use of interpreter based threads from perl
30. threads::shared - Perl extension for sharing data structures between threads
31. utf8 - Enable/disable UTF-8 (or UTF-EBCDIC) in source code
32. vars - Predeclare global variable names (obsolete)
33. vmsish - Control VMS-specific language features
34. warnings - Control optional warnings
35. warnings::register - Warnings import function

Modules Distributed With Perl
Here is listing of the 300+ modules distributed with Perl. For more information enter the following at a command line.

     perldoc Module::Name

1. AnyDBM_File - provide framework for multiple DBMs
2. Attribute::Handlers - Simpler definition of attribute handlers
3. AutoLoader - load subroutines only on demand
4. AutoSplit - split a package for autoloading
5. B - The Perl Compiler
6. B::Asmdata - Autogenerated data about Perl ops, used to generate bytecode
7. B::Assembler - Assemble Perl bytecode
8. B::Bblock - Walk basic blocks
9. B::Bytecode - Perl compiler's bytecode backend
10. B::C - Perl compiler's C backend
11. B::CC - Perl compiler's optimized C translation backend
12. B::Concise - Walk Perl syntax tree, printing concise info about ops
13. B::Debug - Walk Perl syntax tree, printing debug info about ops
14. B::Deparse - Perl compiler backend to produce perl code
15. B::Disassembler - Disassemble Perl bytecode
16. B::Lint - Perl lint
17. B::Showlex - Show lexical variables used in functions or files
18. B::Stackobj - Helper module for CC backend
19. B::Stash - show what stashes are loaded
20. B::Terse - Walk Perl syntax tree, printing terse info about ops
21. B::Xref - Generates cross reference reports for Perl programs
22. Benchmark - benchmark running times of Perl code
23. ByteLoader - load byte compiled perl code
24. Carp - warn of errors (from perspective of caller)
25. Carp::Heavy - heavy machinery, no user serviceable parts inside
26. CGI - Simple Common Gateway Interface Class
27. CGI::Apache - Backward compatibility module for CGI.pm
28. CGI::Carp - CGI routines for writing to the HTTPD (or other) error log
29. CGI::Cookie - Interface to Netscape Cookies
30. CGI::Fast - CGI Interface for Fast CGI
31. CGI::Pretty - module to produce nicely formatted HTML code
32. CGI::Push - Simple Interface to Server Push
33. CGI::Switch - Backward compatibility module for defunct CGI::Switch
34. CGI::Util - Internal utilities used by CGI module
35. Class::ISA - report the search path for a class's ISA tree
36. Class::Struct - declare struct-like datatypes as Perl classes
37. CPAN - query, download and build perl modules from CPAN sites
38. CPAN::FirstTime - Utility for CPAN::Config file Initialization
39. CPAN::Nox - Wrapper around CPAN.pm without using any XS module
40. Cwd - get pathname of current working directory
41. Data::Dumper - stringified perl data structures, suitable for both printing and eval
42. DB - programmatic interface to the Perl debugging API (draft, subject to change)
43. DB_File - Perl5 access to Berkeley DB version 1.x
44. DBM_Filter - Filter DBM keys/values
45. DBM_Filter::compress -
46. DBM_Filter::encode -
47. DBM_Filter::int32 -
48. DBM_Filter::null -
49. DBM_Filter::utf8 -
50. Devel::DProf - a Perl code profiler
51. Devel::Peek - A data debugging tool for the XS programmer
52. Devel::PPPort - Perl/Pollution/Portability
53. Devel::SelfStubber - generate stubs for a SelfLoading module
54. Digest - Modules that calculate message digests
55. Digest::base - Digest base class
56. Digest::file - Calculate digests of files
57. Digest::MD5 - Perl interface to the MD5 Algorithm
58. DirHandle - supply object methods for directory handles
59. Dumpvalue - provides screen dump of Perl data.
60. DynaLoader - Dynamically load C libraries into Perl code
61. Encode - character encodings
62. Encode::Alias - alias definitions to encodings
63. Encode::Byte - Single Byte Encodings
64. Encode::CJKConstants - Internally used by Encode::??::ISO_2022_*
65. Encode::CN - China-based Chinese Encodings
66. Encode::CN::HZ - internally used by Encode::CN
67. Encode::Config - internally used by Encode
68. Encode::EBCDIC - EBCDIC Encodings
69. Encode::Encoder - Object Oriented Encoder
70. Encode::Encoding - Encode Implementation Base Class
71. Encode::Guess - Guesses encoding from data
72. Encode::JP - Japanese Encodings
73. Encode::JP::H2Z - internally used by Encode::JP::2022_JP*
74. Encode::JP::JIS7 - internally used by Encode::JP
75. Encode::KR - Korean Encodings
76. Encode::KR::2022_KR - internally used by Encode::KR
77. Encode::MIME::Header - MIME 'B' and 'Q' header encoding
78. Encode::Symbol - Symbol Encodings
79. Encode::TW - Taiwan-based Chinese Encodings
80. Encode::Unicode - Various Unicode Transformation Formats
81. Encode::Unicode::UTF7 - UTF-7 encoding
82. English - use nice English (or awk) names for ugly punctuation variables
83. Env - perl module that imports environment variables as scalars or arrays
84. Errno - System errno constants
85. Exporter - Implements default import method for modules
86. Exporter::Heavy - Exporter guts
87. ExtUtils::Command - utilities to replace common UNIX commands in Makefiles etc.
88. ExtUtils::Command::MM - Commands for the MM's to use in Makefiles
89. ExtUtils::Constant - generate XS code to import C header constants
90. ExtUtils::Constant::Base - base class for ExtUtils::Constant objects
91. ExtUtils::Constant::Utils - helper functions for ExtUtils::Constant
92. ExtUtils::Constant::XS - base class for ExtUtils::Constant objects
93. ExtUtils::Embed - Utilities for embedding Perl in C/C++ applications
94. ExtUtils::Install - install files from here to there
95. ExtUtils::Installed - Inventory management of installed modules
96. ExtUtils::Liblist - determine libraries to use and how to use them
97. ExtUtils::MakeMaker - Create a module Makefile
98. ExtUtils::MakeMaker::bytes - Version-agnostic bytes.pm
99. ExtUtils::MakeMaker::Config - Wrapper around Config.pm
100. ExtUtils::MakeMaker::vmsish - Platform-agnostic vmsish.pm
101. ExtUtils::Manifest - utilities to write and check a MANIFEST file
102. ExtUtils::Mkbootstrap - make a bootstrap file for use by DynaLoader
103. ExtUtils::Mksymlists - write linker options files for dynamic extension
104. ExtUtils::MM - OS adjusted ExtUtils::MakeMaker subclass
105. ExtUtils::MM_AIX - AIX specific subclass of ExtUtils::MM_Unix
106. ExtUtils::MM_Any - Platform-agnostic MM methods
107. ExtUtils::MM_BeOS - methods to override UN*X behaviour in ExtUtils::MakeMaker
108. ExtUtils::MM_Cygwin - methods to override UN*X behaviour in ExtUtils::MakeMaker
109. ExtUtils::MM_DOS - DOS specific subclass of ExtUtils::MM_Unix
110. ExtUtils::MM_MacOS - once produced Makefiles for MacOS Classic
111. ExtUtils::MM_NW5 - methods to override UN*X behaviour in ExtUtils::MakeMaker
112. ExtUtils::MM_OS2 - methods to override UN*X behaviour in ExtUtils::MakeMaker
113. ExtUtils::MM_QNX - QNX specific subclass of ExtUtils::MM_Unix
114. ExtUtils::MM_Unix - methods used by ExtUtils::MakeMaker
115. ExtUtils::MM_UWIN - U/WIN specific subclass of ExtUtils::MM_Unix
116. ExtUtils::MM_VMS - methods to override UN*X behaviour in ExtUtils::MakeMaker
117. ExtUtils::MM_VOS - VOS specific subclass of ExtUtils::MM_Unix
118. ExtUtils::MM_Win32 - methods to override UN*X behaviour in ExtUtils::MakeMaker
119. ExtUtils::MM_Win95 - method to customize MakeMaker for Win9X
120. ExtUtils::MY - ExtUtils::MakeMaker subclass for customization
121. ExtUtils::Packlist - manage .packlist files
122. ExtUtils::testlib - add blib/* directories to @INC
123. Fatal - replace functions with equivalents which succeed or die
124. Fcntl - load the C Fcntl.h defines
125. File::Basename - Parse file paths into directory, filename and suffix.
126. File::CheckTree - run many filetest checks on a tree
127. File::Compare - Compare files or filehandles
128. File::Copy - Copy files or filehandles
129. File::DosGlob - DOS like globbing and then some
130. File::Find - Traverse a directory tree.
131. File::Glob - Perl extension for BSD glob routine
132. File::Path - create or remove directory trees
133. File::Spec - portably perform operations on file names
134. File::Spec::Cygwin - methods for Cygwin file specs
135. File::Spec::Epoc - methods for Epoc file specs
136. File::Spec::Functions - portably perform operations on file names
137. File::Spec::Mac - File::Spec for Mac OS (Classic)
138. File::Spec::OS2 - methods for OS/2 file specs
139. File::Spec::Unix - File::Spec for Unix, base for other File::Spec modules
140. File::Spec::VMS - methods for VMS file specs
141. File::Spec::Win32 - methods for Win32 file specs
142. File::stat - by-name interface to Perl's built-in stat() functions
143. File::Temp - return name and handle of a temporary file safely
144. FileCache - keep more files open than the system permits
145. FileHandle - supply object methods for filehandles
146. Filter::Simple - Simplified source filtering
147. Filter::Util::Call - Perl Source Filter Utility Module
148. FindBin - Locate directory of original perl script
149. Getopt::Long - Extended processing of command line options
150. Getopt::Std - Process single-character switches with switch clustering
151. Hash::Util - A selection of general-utility hash subroutines
152. I18N::Collate - compare 8-bit scalar data according to the current locale
153. I18N::Langinfo - query locale information
154. I18N::LangTags - functions for dealing with RFC3066-style language tags
155. I18N::LangTags::Detect - detect the user's language preferences
156. I18N::LangTags::List - tags and names for human languages
157. IO - load various IO modules
158. IO::Dir - supply object methods for directory handles
159. IO::File - supply object methods for filehandles
160. IO::Handle - supply object methods for I/O handles
161. IO::Pipe - supply object methods for pipes
162. IO::Poll - Object interface to system poll call
163. IO::Seekable - supply seek based methods for I/O objects
164. IO::Select - OO interface to the select system call
165. IO::Socket - Object interface to socket communications
166. IO::Socket::INET - Object interface for AF_INET domain sockets
167. IO::Socket::UNIX - Object interface for AF_UNIX domain sockets
168. IPC::Msg - SysV Msg IPC object class
169. IPC::Open2 - open a process for both reading and writing
170. IPC::Open3 - open a process for reading, writing, and error handling
171. IPC::Semaphore - SysV Semaphore IPC object class
172. IPC::SysV - SysV IPC constants
173. List::Util - A selection of general-utility list subroutines
174. Locale::Constants - constants for Locale codes
175. Locale::Country - ISO codes for country identification (ISO 3166)
176. Locale::Currency - ISO three letter codes for currency identification (ISO 4217)
177. Locale::Language - ISO two letter codes for language identification (ISO 639)
178. Locale::Maketext - framework for localization
179. Locale::Script - ISO codes for script identification (ISO 15924)
180. Math::BigFloat - Arbitrary size floating point math package
181. Math::BigInt - Arbitrary size integer/float math package
182. Math::BigInt::Calc - Pure Perl module to support Math::BigInt
183. Math::BigInt::CalcEmu - Emulate low-level math with BigInt code
184. Math::BigRat - Arbitrary big rational numbers
185. Math::Complex - complex numbers and associated mathematical functions
186. Math::Trig - trigonometric functions
187. Memoize - Make functions faster by trading space for time
188. Memoize::AnyDBM_File - glue to provide EXISTS for AnyDBM_File for Storable use
189. Memoize::Expire - Plug-in module for automatic expiration of memoized values
190. Memoize::ExpireFile - test for Memoize expiration semantics
191. Memoize::ExpireTest - test for Memoize expiration semantics
192. Memoize::NDBM_File - glue to provide EXISTS for NDBM_File for Storable use
193. Memoize::SDBM_File - glue to provide EXISTS for SDBM_File for Storable use
194. Memoize::Storable - store Memoized data in Storable database
195. MIME::Base64 - Encoding and decoding of base64 strings
196. MIME::QuotedPrint - Encoding and decoding of quoted-printable strings
197. NDBM_File - Tied access to ndbm files
198. Net::Cmd - Network Command class (as used by FTP, SMTP etc)
199. Net::Config - Local configuration data for libnet
200. Net::Domain - Attempt to evaluate the current host's internet name and domain
201. Net::FTP - FTP Client class
202. Net::hostent - by-name interface to Perl's built-in gethost*() functions
203. Net::netent - by-name interface to Perl's built-in getnet*() functions
204. Net::Netrc - OO interface to users netrc file
205. Net::NNTP - NNTP Client class
206. Net::Ping - check a remote host for reachability
207. Net::POP3 - Post Office Protocol 3 Client class (RFC1939)
208. Net::protoent - by-name interface to Perl's built-in getproto*() functions
209. Net::servent - by-name interface to Perl's built-in getserv*() functions
210. Net::SMTP - Simple Mail Transfer Protocol Client
211. Net::Time - time and daytime network client interface
212. NEXT - Provide a pseudo-class NEXT (et al) that allows method redispatch
213. O - Generic interface to Perl Compiler backends
214. Opcode - Disable named opcodes when compiling perl code
215. PerlIO - On demand loader for PerlIO layers and root of PerlIO::* name space
216. PerlIO::encoding - encoding layer
217. PerlIO::scalar - in-memory IO, scalar IO
218. PerlIO::via - Helper class for PerlIO layers implemented in perl
219. PerlIO::via::QuotedPrint - PerlIO layer for quoted-printable strings
220. Pod::Checker - check pod documents for syntax errors
221. Pod::Find - find POD documents in directory trees
222. Pod::Functions - Group Perl's functions a la perlfunc.pod
223. Pod::Html - module to convert pod files to HTML
224. Pod::InputObjects - objects representing POD input paragraphs, commands, etc.
225. Pod::LaTeX - Convert Pod data to formatted Latex
226. Pod::Man - Convert POD data to formatted *roff input
227. Pod::ParseLink - Parse an L<> formatting code in POD text
228. Pod::Parser - base class for creating POD filters and translators
229. Pod::ParseUtils - helpers for POD parsing and conversion
230. Pod::Perldoc::ToChecker - let Perldoc check Pod for errors
231. Pod::Perldoc::ToMan - let Perldoc render Pod as man pages
232. Pod::Perldoc::ToNroff - let Perldoc convert Pod to nroff
233. Pod::Perldoc::ToPod - let Perldoc render Pod as ... Pod!
234. Pod::Perldoc::ToRtf - let Perldoc render Pod as RTF
235. Pod::Perldoc::ToText - let Perldoc render Pod as plaintext
236. Pod::Perldoc::ToTk - let Perldoc use Tk::Pod to render Pod
237. Pod::Perldoc::ToXml - let Perldoc render Pod as XML
238. Pod::Plainer - Perl extension for converting Pod to old style Pod.
239. Pod::PlainText - Convert POD data to formatted ASCII text
240. Pod::Select - extract selected sections of POD from input
241. Pod::Text - Convert POD data to formatted ASCII text
242. Pod::Text::Color - Convert POD data to formatted color ASCII text
243. Pod::Text::Overstrike - Convert POD data to formatted overstrike text
244. Pod::Text::Termcap - Convert POD data to ASCII text with format escapes
245. Pod::Usage - print a usage message from embedded pod documentation
246. POSIX - Perl interface to IEEE Std 1003.1
247. Safe - Compile and execute code in restricted compartments
248. Scalar::Util - A selection of general-utility scalar subroutines
249. SDBM_File - Tied access to sdbm files
250. Search::Dict - search for key in dictionary file
251. SelectSaver - save and restore selected file handle
252. SelfLoader - load functions only on demand
253. Shell - run shell commands transparently within perl
254. Socket - load the C socket.h defines and structure manipulators
255. Storable - persistence for Perl data structures
256. Switch - A switch statement for Perl
257. Symbol - manipulate Perl symbols and their names
258. Sys::Hostname - Try every conceivable way to get hostname
259. Sys::Syslog - Perl interface to the UNIX syslog(3) calls
260. Term::ANSIColor - Color screen output using ANSI escape sequences
261. Term::Cap - Perl termcap interface
262. Term::Complete - Perl word completion module
263. Term::ReadLine - Perl interface to various readline packages. If no real package is found, substitutes stubs instead of basic functions.
264. Test - provides a simple framework for writing test scripts
265. Test::Builder - Backend for building test libraries
266. Test::Builder::Module - Base class for test modules
267. Test::Builder::Tester - test testsuites that have been built with Test::Builder
268. Test::Builder::Tester::Color - turn on colour in Test::Builder::Tester
269. Test::Harness - Run Perl standard test scripts with statistics
270. Test::Harness::Assert - simple assert
271. Test::Harness::Iterator - Internal Test::Harness Iterator
272. Test::Harness::Point - object for tracking a single test point
273. Test::Harness::Straps - detailed analysis of test results
274. Test::More - yet another framework for writing test scripts
275. Test::Simple - Basic utilities for writing tests.
276. Text::Abbrev - create an abbreviation table from a list
277. Text::Balanced - Extract delimited text sequences from strings.
278. Text::ParseWords - parse text into an array of tokens or array of arrays
279. Text::Soundex - Implementation of the Soundex Algorithm as Described by Knuth
280. Text::Tabs - expand and unexpand tabs per the unix expand(1) and unexpand(1)
281. Text::Wrap - line wrapping to form simple paragraphs
282. Thread - manipulate threads in Perl (for old code only)
283. Thread::Queue - thread-safe queues
284. Thread::Semaphore - thread-safe semaphores
285. Tie::Array - base class for tied arrays
286. Tie::File - Access the lines of a disk file via a Perl array
287. Tie::Handle - base class definitions for tied handles
288. Tie::Hash - base class definitions for tied hashes
289. Tie::Memoize - add data to hash when needed
290. Tie::RefHash - use references as hash keys
291. Tie::Scalar - base class definitions for tied scalars
292. Tie::SubstrHash - Fixed-table-size, fixed-key-length hashing
293. Time::gmtime - by-name interface to Perl's built-in gmtime() function
294. Time::HiRes - High resolution alarm, sleep, gettimeofday, interval timers
295. Time::Local - efficiently compute time from local and GMT time
296. Time::localtime - by-name interface to Perl's built-in localtime() function
297. Time::tm - internal object used by Time::gmtime and Time::localtime
298. Unicode::Collate - Unicode Collation Algorithm
299. Unicode::Normalize - Unicode Normalization Forms
300. Unicode::UCD - Unicode character database
301. UNIVERSAL - base class for ALL classes (blessed references)
302. User::grent - by-name interface to Perl's built-in getgr*() functions
303. User::pwent - by-name interface to Perl's built-in getpw*() functions
304. XS::APItest - Test the perl C API
305. XS::Typemap - module to test the XS typemaps distributed with perl
306. XSLoader - Dynamically load C libraries into Perl code

If you have any suggestions for additions to these tutorials, please let me know.