# My module

...code...

42;
[download]

package MyValidate; # use package to declare a module
our $val;

sub val_time {
    $val = shift;
    $val = ($val =~ /^(\d{2}):(\d{2}) (am|pm)$/) ? "$1:$2 $3" : 1;
}

1;
[download]

package MyValidate; # use package to declare a module

sub val_time {
    my $val = shift;
    $val = ($val =~ /^(\d{2}):(\d{2}) (am|pm)$/) ? "$1:$2 $3" : 1;
    return $val; # yes this is not necessary but it clarifies my inten
+sion
}

1;
[download]

You start it with a shebang line, which is an odd thing to do since it is not actually executed (nor will any flags such as -w be parsed from the line by perl).

Usually (but only optionally) a module will declare its own name space and only export to the use'ing code subs that are requested:

in MyModule.pm:

package MyModule;
use Exporter ();
our @ISA = 'Exporter';
our @EXPORT_OK = qw/foo bar/;
sub foo { "do some foo stuff" }
sub bar { "do some bar stuff" }
1; # not actually needed since @EXPORT_OK= evaluates as true
[download]

use MyModule 'foo';
&foo();
[download]

One last comment: one-level all-lowercase names like "validate" are usually for pragmas and are reserved for use by perl5-porters.

Actually, better not to export at all:

in MyModule.pm:

package MyModule;

sub new { bless {}, shift }
sub foo { "do some foo stuff" }
1;
[download]

and in the calling code:

use MyModule;
my $o = new MyModule;

$o->foo();
[download]

$o is an object. It can have data, but in this case, it is just a way to tell perl where to find the subroutine foo(). This means you could have several different modules, each with a routine named 'foo;, and by using the object each module returns (customarily) from the call to new(), you can tell them apart. Whereas if you have the misfortune to use 2 modules that both export foo into your namespace, who knows what happens?

--Bob Niederman, http://bob-n.com

All code given here is UNTESTED unless otherwise stated.

I would rather use class methods than create a dummy object with no other purpose than to qualify the package to call.

File::Spec is an excellent example of when that works well.

In the more typical case, however, you would be just as well off importing nothing and always fully qualifying your calls (e.g. MyModule::foo() ). Importing some things is a programmer convenience to save typing and improve readability. If the sub names reflect what they do, conflicts should be rare (and can always be resolved by fully qualifying).

Egads, far too many uses of OO are superfluous and/or ill advised already and now you want OO for simple library calls. Just use fully qualified package names:

#### MyMod.pm
package MyMod;
sub foo { "whatever" }
1;

### calling script
#!/usr/bin/perl -w
use strict;
use MyMod;
print MyMod::foo();
[download]

#!/usr/bin/perl

print "Content-type: text/plain\n\n";

use strict;
use CGI::Carp qw(fatalsToBrowser);
use Validate;

my $the_time = "12:23 pm";

Validate::val_time($the_time);

$the_time = $Validate::val;  

if ($the_time) { print "$the_time\n" } else { print "error\n" }
[download]

package Validate; # use package to declare a module

our $val;

sub val_time {
    $val = shift;
    $val = ($val =~ /^(\d{2}):(\d{2}) (am|pm)$/) ? "$1:$2 $3" : 1;
    return $val;   #worked with and without this line
}

1;
[download]