Monthly Archives: May 2009

Some notes for me as I attempt to get a better understanding of Perl’s variable scoping rules. A work in progress…

• Perl has 2 separate ‘namespaces’ for variables – package aka global (Perl 4) and my aka private aka lexical scoping (Perl 5)
• the default package is main, this can be changed with the statement package foo; which then applies to all subsequent code until another package statement is encountered
• lexical scoping is done with {} (either via subroutines/operators or ‘naked blocks’); the top level is the file itself (‘file level’).
• use strict; (specifically use strict ‘vars’;) requires that variables either use a package qualifier (eg $main::foo) if they’re package variables or be lexical variables declared with my. You can get around this extra typing for package variables with use vars (or no strict ‘vars’ for a block)
• our($foo,$bar) is like use vars qw($foo $bar), however it’s lexical ie can be restricted by {}’s (an equivalent no use vars doesn’t exist). Looked at it another way, our ‘spans’ package declarations (as it’s lexical) whereas use vars is ‘reset’ by package declarations.

Also:

• dynamic scoping is done with local – see Wikipedia – Scope (programming). Lexical scoping is the norm in modern programming languages, dynamic scoping is a Lisp’y idea that uses a sort of stack for variable scope resolution, that can only be determined at runtime.  When to use local? Rarely… Seven Useful Uses of local
• local only works with package variables not lexical/my variables; an example of where local can be useful is to temporarily change a Global Special Variable (eg $) $EFFECTIVE_GROUP_ID) before calling a subroutine: “local saves away the value of a package global and substitutes a new value for all code within and called from the block in which the local declaration is made” eg

{
    local $) = getgrnam(USER) if $< == 0;
    enable($host);
}

• do C-style static variables in this manner:

        { my $seed = 1;
          sub my_rand {
            $seed = int(($seed * 1103515245 + 12345) / 65536) % 32768;
            return $seed;
          }
        }

• xx

Some Links:

• Coping with Scoping
• Perl Monks -Variable Scoping in Perl: the basics

Some notes on Perl’s use, require, import and do. Quick notes for me; not meant to be authoritative…

• use is done at ‘compile-time’ and require is done at ‘run-time’ (ie can conditionally load modules)
• require is the older method, but use uses require to do it’s work:

use Foo;   # equivalent to:
require Foo; Foo->import();
.
use Foo qw (foo bar);   # equivalent to:
require Foo; Foo->import(qw(foo bar));
.
use Foo();   # equivalent to:
require Foo;   # ie don't import anything, not even the default things

• a Library is a just a file of code; a Module has package Foo in it (and usually other stuff)
• use only works with modules, whereas require works with both modules and libraries. Corollary: use only works with module names (Foo), whereas require also works with paths (eg ~/lib/foo.pm)
• require Foo will check if Foo has already been loaded, whereas do Foo will unconditionally reload Foo
• better practice is to write modules rather than librarys, to prevent namespace pollution. A simple module:

package Foo;   # minimal. Usually add things like:
use base qw (Exporter);
our @EXPORT = qw(qux slarken);   # keep this list small - namespace pollution


• to use this module:

use lib '~/lib'; # add this to %INC
use Foo;   # loads module, imports symbols in @EXPORT
Foo->bar();   # correct
Foo::bar();   # works, but not for inherited methods
qux();   # works, due to export
bar();   # carks


Some links:

• netalive.org – Writing Serious Perl
• Randal L. Schwartz – Hey use guys! import this!
• perl.com – The Perl You Need To Know – Part 3
• hype-free – The difference between use and require in Perl
• perldoc – use
• Perl Cookbook – Packages, Libraries and Modules