Perl Modular Programming .. Tutorial and short notes

This post describes Perl Modules in short or kind of notes taken from "Advance Perl Programming" book.

PERL Modules

        * Modules are nothing but library packages, that can be
          reused efficiently and provides a means for Modular
          Programming

        * Perl uses keywork 'package' to define modules and loads
          predefined modules using 'use' and 'required' keywords.
          To access package specific variables and function it
          uses '::' notation.

        * required keyword is similar like C #include, which loads
          the perl file. e.g. required "myfunction.pl";

        * 'use' statement is executed as soon as it is parsed. So
          at compile time it is guarantee that all required modules
          have been successfully loaded at compile time.

        * Perl modules files using stored with extension '.pm'

Perl Package/Module example

simple example of perl package includes variable and function 

definitions. E.g. mypackage.pm

        #!/usr/bin/perl

        package mypackage; # same as filename

        # global variables
        my $space_count;

        sub readspaces
        {
                my ($string) = (@_);
                $space_count = map $_, $string =~ /\s/gs;
                return $space_count;
        }

        sub replacespaces
        {
                my ($string) = (@_);
                $string =~ s/\s/\#/g;
                return $string;
        }

        1; # to avoid error "mypackage.pm did not return a true value"
           # also when it is included with 'use' or 'required' module
           # is expected to return a boolen success value

Main package and variables

In absence of explicit package declaration, perl assumes a package 'main'. The built-in variables such as $!, $_, $@, @ARGV and %ENV are belongs to package main and these are only truly  global variables in Perl.

 

Symbolic References

Used more in Object orientation. Calling a function or variable using symbols.    E.g.  Calling function from package mypackage,
 

             $mypackage::myfunction(10,20);

    

The symbolic reference for this above function calling is:
           

             &{"mypackage::myfunction"}(10,20);

Package Initialization & Destruction

Use of BEGIN block does a initialization work for perl modules. The perl when it seens BEGIN block it executes right away and does further compilation later on. Simple requirement when we want to include a library before compilation, we can add below line in BEGIN block:

          sub BEGIN {
              use lib qw(../include); #prepends the directory to @INC
          } 

Similarly END block is used to do clean-up before the program exits.

Enforcing privacy

Use 'my' operator at file scope.
          e.g.
                package A;
                my $a = 10;

                package B;
                print $A::a; # error, no such variable in package A
                print $a # print 10 

Define a function with 'my'
          e.g.
                my $rs_func  = sub {
                        };
                #call as
                &$rs_func;

 

Importing Symbols

Creating namespaces and using function names or variables directly without using '::' operator. While defining the package use Exporter module insert all the package function names and variables to Exporter array. Which this inherits to the calling program. e.g.

          package BankAccount;
          use Exporter;
          @ISA = ('Exporter');
          @Exporter_OK = qw/withdraw deposite/; # or use below
          # Exporter_OK states only these symbols are ok to export
          @Exporter = qw/withdraw/; # this gets all the exported symbols

          sub withdraw { ... }
          sub deposite { ... }
          1; 

          # myfile.pl
          #!/usr/bin/perl
          use BankAccount ('deposite'); # this is analogus to
             # BEGIN { require BankAccount;
             #         BankAccount::import('deposite');
             # }

 

Package nesting

Since all packages are global in scope nesting is not permitted. but one can use a directory, the '::' gets replaced with a filename separator. e.g.
 

          use Math::Poisson; # Math/Poisson.pm
          Math::Poisson::Calculate_Probability($lamda, $a);

 

Autoloading

If you invoke a function called Test::func(), for example, and if func() has not been defined in module Test, Perl automatically looks for a subroutine called Test::AUTOLOAD(). If such a subroutine exists, Perl calls it with the arguments
that were passed to func(). In addition, a variable called  $AUTOLOAD is set to the full name of the function that was  called ("Test::func").

Usefull example is calling system with linux command
        #-----------------------------------------------
        package Shell;
        #------------------------------------------
        sub AUTOLOAD {
            my($program) = $AUTOLOAD;
            # We are just interested in the command name, not in
            # the package name
            $program =~ s/^.*:://;
            system ("$program @_");
        }
 

        #------------------------------------------------
        use Shell;
        ls ('-lR'); # Triggers a call to AUTOLOAD since sub ls()
        # doesn't exist
        mail ('-s "This is a test" joe@foo.com < letter.txt');

Accessing Symbol table

Dumping a package symbol table using stashing the function  e.g. function name foo can be accessed by a hash %foo
                TODO
 

Questions on perl modules/packages

1. How do you make variables public, private, or protected in Perl?

        use 'my' for private and 'our' keyword for public
        use 'local' might bring protected version

2. use vs require keyword. How to create module

        Use and Require are most common methods used to load modules.
        Use:
          1) It is evaluated at compile time only.
          2) it is used only to load modules.
          3)No need to give file extensions when we are using "use"
        Require:
          1)This is evaluated at Run time
          2)This method is used for both libraries and modules.
          3)Need to give file extensions like pl,pm etc..

3. List the programming guidelines that must be followed when programming
   with Perl modules

        * The Module and the package name must be the same.
        * The only allowable package name needs to have the extension “.pm”
        * The package must be derived from the exporter class when no
          object-oriented technique is used