Ports Search

The Portable Coroutine Library (PCL) implements the low level functionality for coroutines. For a definition of the term coroutine see The Art of Computer Programming by Donald E. Knuth. Coroutines are a very simple cooperative multitasking environment where the switch from one task to another is done explicitly by a function call.

Class::Autouse allows you to specify a class the will only load when a method of that class is called. For large classes that might not be used during the running of a program, such as Date::Manip, this can save you large amounts of memory, and decrease the script load time.

This module is intended to provide a general-purpose date and datetime type for perl. You have a Class::Date class for absolute date and datetime, and have a Class::Date::Rel class for relative dates. You can use ``+'', ``-'', ``<'' and ``>'' operators as with native perl data types.

The Class::MakeMethods framework allows Perl class developers to quickly define common types of methods. When a module "use"s a subclass of Class::MakeMethods, it can select from the supported method types, and specify a name for each method desired. The methods are dynamically generated and installed in the calling package.

You can define multimethods with the "multi" declarator: use Class::Multimethods::Pure; multi collide => ('Bullet', 'Ship') => sub { my ($a, $b) = @_; ... }; multi collide => ('Ship', 'Asteroid') => sub { my ($a, $b) = @_; ... }; It is usually wise to put such declarations within a BEGIN block, so they behave more like Perl treats subs (you can call them without parentheses and you can use them before you define them).

This distribution facilitates the run-time generation of classes which inherit from a base class and some optional selection of mixin classes. A factory is provided to generate the mixed classes with multiple inheritance. A NEXT method allows method redispatch up the inheritance chain.

This package provides a framework for rapid Object Oriented Perl application development. It consists of a number of base classes that are similar to the C++/STL framework, plus a number of helper classes which provide the glue to transparently generate common functions, and will enable you to put your Perl application together very quickly.

This module implements a minimal lightweight exception object. It is meant to be a compromise between more basic solutions like Carp which can only print information and cannot handle exception objects, and more complex solutions like Exception::Class which can be used to define complex inline exceptions and has a number of module dependencies.

Config::JFDI is an implementation of Catalyst::Plugin::ConfigLoader that exists outside of Catalyst. Essentially, Config::JFDI will scan a directory for files matching a certain name. If such a file is found which also matches an extension that Config::Any can read, then the configuration from that file will be loaded.

Apache Ant, a Java-based build tool, conceptually similar to make. Ant uses XML build files that defines a set of targets. Each target has dependencies (other targets) and contains a set of tasks to perform. There are tasks for various things, like compiling ("javac"), copying ("copy"), deleting ("delete"), executing other programs ("java", "exec", "execon", etc.), stylesheet transformations ("style") and so on.