lecture in color

Localizing globals

So far, we've just been learning the language.
We note that although there's always "more than one way to do it",
- many ways are downright confusing.
- some ways exhibit stronger semantics (e.g., the substitution principle) than others.
Key to surviving Perl is not just knowing the language.
Need to develop a paradigm of programming that transcends language semantics.
This paradigm tells us how to do several things:
- Craft inference rules that reduce what we need to remember about language semantics.
- Craft programs that minimize what we need to remember in order to understand them.
First paradigm is that of localizing references.

Caveat: separation of method and discipline

Most languages are built around the idea that stricture is required by default and that relaxation of the rules of good coding is only available by request.
Perl is built around the idea that discipline is separate from method. There are no intrinsic default methods for enforcement of good programming practice and style in the language itself.
Instead, strictures are options that we, as programmers must impose upon our Perl code as we wish.
Unfortunately, they might as well be required; it is almost impossible to write robust perl code without them.

Localization of binding

By default, all variables and functions have global scope and unlimited lifetime (like in old-style BASIC!).
If we casually use a variable $i in a subroutine, its value persists in global scope.
If we then reuse it, that value persists.
So we have to remember the state of all variables to understand a program.
Need to somehow localize a variable to limit its scope.
The language supports but does not enforce several methods for accomplishing this.

Kinds of localization of binding

Global variable and function scope control: packages.
Variable scope control:
- In block: my
- In package: our
- In execution environment: local
Value scope control: bless.

Packages

extension of namespace concept.
the normal package is 'main'
can define any number of other packages having
- their own variables
- their own subroutines
- their own filehandles
- etc.
the syntax:
```
package foo; 
$bar = 1; 
```
defines a variable $foo::bar (package foo, variable bar).
Packages contain their own symbol tables for all kinds of variables, including scalars, arrays, hashes, functions, filehandles, and typeglobs. E.g.
```
package foo; 
sub strate { 
    $name = shift; 
    open(FILE, "<$name") or die "can't open $name: $!"; 
    @content = (<FILE>); 
    close FILE; 
    return $content[0]; 
} 
&strate('foo'); 
```
defines:
- &foo::strate a function.
- $foo::name a scalar.
- $foo::FILE a filehandle.
- @foo::content an array.
So these variables aren't in the default namespace main::.

Why use a package?

Group together variables and functions that work together, within one set of namespaces.
Make it easy to reuse the same code in multiple Perl programs without name collisions.
Can emulate C++ classes with packages (though functionality is limited and -- sometimes -- downright strange).

Declarations (PP chapter 4)

Although you don't have to, you can declare variables in Perl.
Declarations don't keep variables from being global; they simply limit the scope in which a variable is treated as global. This is a bit strange and takes some time to get used to.
If not declared, variables are dynamic, global, and persistent.
- dynamic: variables appear when referenced.
- global: variables thus created can be referenced in any and all code you write.
- persistent: variables stay around until the end of execution (this is a lifetime attribute).
Watch out! Variables that are used before they're defined do not generate a runtime error in Perl.
- The numeric value of undef is 0.
- The string value of undef is ''.
Declarations limit variables to being a bit less ubiquitous.
my $var; - lexical scoping and lifetime, local to a block, {...}, automatically destroyed upon block exit.
our $var; - lexical scoping within a file, available to all packages within the file, sort of a "localized global variable".
local $var; - dynamic scoping, block lifetime, local to a block, automatically destroyed at block exit, available to subroutines called within its scope as a global variable. Package-sensitive; declarations can contain package name, even a different package from the current one! e.g. local $foo::debug;

`my $var;`

makes a variable statically (lexically and locally) scoped.
only available to this subroutine or within the current block and its lexical sub-blocks.
if declared outside any block, acts like our: scope is whole file.
not available to subroutines you call unless they're declared inside the same block (and this is weird);
not available to the subroutine that called you.
destroyed when execution exits the block that it's within.
Typical use of my: localizing variables to avoid naming conflicts.

Consider:

contents of perl_decl/my1.pl...
#! /var/local/couch/bin/perl 
sub scriber { 
    my ($name,$value) = @_; 
    print "pay $name \$$value immediately\n"; 
} 

&scriber('Couch', 20); 
print "name=$name\n"; 

sub verted { 
   ($name,$value) = @_; 
    print "pay $name \$$value immediately\n"; 
} 

&verted('Couch', 20); 
print "name=$name\n"; 

...end of perl_decl/my1.pl

This prints:

contents of perl_decl/my1.pl.out...
pay Couch $20 immediately
name=
pay Couch $20 immediately
name=Couch
...end of perl_decl/my1.pl.out

The my declarations keep the subroutine arguments from cluttering up global variable space.

Strange example: there is a scope in which my variables are passed to subroutines:

contents of perl_decl/my2.pl...
#! /var/local/couch/bin/perl 

{ 
   my $var = "hi there"; 
   sub stitute { 
       $var .= shift; 
       print "var=$var\n"; 
   } 
} 

&stitute(" person"); 
&stitute(", how are you?"); 

print "var=$var\n"; 


...end of perl_decl/my2.pl

This prints:

contents of perl_decl/my2.pl.out...
var=hi there person
var=hi there person, how are you?
var=
...end of perl_decl/my2.pl.out

The my declaration defines a variable that acts like a global variable for subroutines declared within its scope. So this construction declares a static local variable for the subroutine!

`our $var;`

Makes a variable lexically scoped within the current file, with unlimited lifetime.
Scope of the variable is from the declaration -- within the current package -- to the end of the file in which the variable is declared (or until the next contrasting declaration).
Other packages declared in the file can see the variable.
Variable is made part of the current package (though it is visible to others).
Scope is not local to a block (unlike my, whose scope is always local to some block).

Consider:

contents of perl_decl/our1.pl...
#! /var/local/couch/bin/perl 

$name = "foo"; 

print "before our, name=$name\n"; 

package Foo; 

print "before our, in Foo, name=$name\n"; 

package main; 

{ 
    our $name = "Couch"; 
    print "inside block, name=$name\n"; 
} 

print "outside block, name=$name\n"; 

package Foo; 

print "in package Foo, name=$name\n"; 

sub verted { 
    print "in subroutine verted, name=$name\n"; 
} 

&verted; 

package main; 

print "back in package main, name=$name\n"; 

...end of perl_decl/our1.pl

This prints:

contents of perl_decl/our1.pl.out...
before our, name=foo
before our, in Foo, name=
inside block, name=Couch
outside block, name=Couch
in package Foo, name=
in subroutine verted, name=
back in package main, name=Couch
...end of perl_decl/our1.pl.out

The variable isn't visible inside package Foo but remains visible when we hop back to package Main.

`local $var;`

makes a new dynamically scoped variable with block lifetime.
sort of a 'temporary global'.
always refers to a variable in some package.
local to the current package (or can specify package).
available to subroutines you call.
not available to the subroutine that called you.
can shadow and protect an existing global.
destroyed when execution exits the block in which it's defined.

Consider:

contents of perl_decl/local1.pl...
#! /var/local/couch/bin/perl 

$debug = undef; 

{ &debug ("hi there\n");     # this doesn't print
  { local $debug = 1; 
    &debug ("ho there\n");   # this does print
  } 
  &tle; 
  &debug ("hello, hello, hello (hello)\n"); # this doesn't print
} 

sub tle { 
  local $debug = 1; # shadows global declaration 
  &debug ("gripe gripe gripe...\n"); # this does print 
} 


sub debug { 
    printf @_ if $debug; 
} 
...end of perl_decl/local1.pl

This prints:

contents of perl_decl/local1.pl.out...
ho there
gripe gripe gripe...
...end of perl_decl/local1.pl.out

This is a typical use of local: to temporarily override a global default.

Very important: in the above example, the package name (main) was implicit. We could make it explicit as follows:

contents of perl_decl/local2.pl...
#! /var/local/couch/bin/perl 

$main::debug = undef; 

{ &main::debug ("hi there\n");     # this doesn't print
  { local $main::debug = 1; 
    &main::debug ("ho there\n");   # this does print
  } 
  &main::tle; 
  &main::debug ("hello, hello, hello (hello)\n"); # this doesn't print
} 

sub main::tle { 
  local $main::debug = 1; # shadows global declaration 
  &debug ("gripe gripe gripe...\n"); # this does print 
} 


sub main::debug { 
    printf @_ if $main::debug; 
} 
...end of perl_decl/local2.pl

Shadowing

Declaring a variable with the same name and type as another shadows the other variable.
Obeys block structure.
The innermost and latest declaration according to block structure always wins.

Consider:

contents of perl_decl/shadow.pl...
#! /var/local/couch/bin/perl 

# shadowing demonstration 

$foo = 'manny';
print "on outside, foo=$foo\n"; 
{ 
    my $foo = 'moe'; 
} 

sub version { 
    print "in version, foo=$foo\n"; 
    local $foo = 'jack'; 
    print "in version, foo=$foo\n"; 
    &ject; 
} 

sub ject { 
   print "in ject, foo=$foo\n"; 
} 

&version; 
&ject; 

print "on outside, foo=$foo\n"; 
...end of perl_decl/shadow.pl

This prints:

contents of perl_decl/shadow.pl.out...
on outside, foo=manny
in version, foo=manny
in version, foo=jack
in ject, foo=jack
in ject, foo=manny
on outside, foo=manny
...end of perl_decl/shadow.pl.out

Scoping demonstration

Consider:

contents of perl_decl/scope1.pl...
#! /var/local/couch/bin/perl

# examples of scoping
sub checkit { 
    if (defined $i) { 
        print "inside checkit, \$i is $i\n"; 
    } else { 
        print "inside checkit, \$i is undefined\n"; 
    } 
} 

# my declaration inside a block limits $i to that block
print "\ntest \$i in STATIC scope\n"; 
{ my $i = 7; 
  if (defined $i) { 
      print "inside block \$i is $i\n"; 
  } else { 
      print "inside block \$i is undefined\n"; 
  } 
  &checkit; 
}

if (defined $i) { 
    print "outside block \$i=$i\n"; 
} else { 
    print "outside block \$i is undefined\n"; 
} 

# local declaration inside a block limits $i to that block 
# and subroutines invoked in that block. 
print "\ntest \$i in DYNAMIC scope\n"; 
{ local $i = 21; 
  if (defined $i) { 
      print "inside block \$i is $i\n"; 
  } else { 
      print "inside block \$i is undefined\n"; 
  } 
  &checkit; 
} 

if (defined $i) { 
    print "outside block \$i=$i\n"; 
} else { 
    print "outside block \$i is undefined\n"; 
} 

# if no declaration, $i is global. 
print "\ntest \$i in GLOBAL scope\n"; 
{ $i = 42; 
  if (defined $i) { 
      print "inside block \$i is $i\n"; 
  } else { 
      print "inside block \$i is undefined\n"; 
  } 
  &checkit; 
}

if (defined $i) { 
    print "outside block \$i is $i\n"; 
} else { 
    print "outside block \$i is undefined\n"; 
} 

...end of perl_decl/scope1.pl

This prints:

contents of perl_decl/scope1.pl.out...

test $i in STATIC scope
inside block $i is 7
inside checkit, $i is undefined
outside block $i is undefined

test $i in DYNAMIC scope
inside block $i is 21
inside checkit, $i is 21
outside block $i is undefined

test $i in GLOBAL scope
inside block $i is 42
inside checkit, $i is 42
outside block $i is 42
...end of perl_decl/scope1.pl.out

Why scoping?

confusion results from too many global variables.
subroutines get access to all of them.
leads to programming errors.

Basic 'rule of scope'

Make scope of a variable as restrictive as possible.
Use 'my' whenever possible.
Use 'our' to declare global variables that are local to packages and whose lifetime is all of execution.
Use 'local' sparingly and when justified; main use is to temporarily override a global default. (it is quite difficult to justify it, and cases are very rare).
Use true global variables for defaults that can change, and nothing else.
When possible, use subroutines rather than variables to reflect the values of constants that can't change during execution.

`use strict`

Perl allows one to be very sloppy in coding.
- leaving out & on function calls.
- mixing up local and global variables.
The pragma use strict causes the language to become "more demanding":
- Global variables must be declared using our or referred to by their full names (package::var).
- Local variables must be declared by my.
- No sloppy use of strings as other things.
- In practice, this may be too strict.
I typically use:
```
 
use strict; 
no strict "refs"; 
```
because there's no way to generate the name of a filehandle with strict "refs" in effect.

Simulating other kinds of declarations

Perl has no other builtin declarations, but one can simulate them.
Constants: simulate numeric constants with subroutines.
Prototypes: simulate declaration of subroutine arguments.
Attributes: simulate declaration of function return value.
Guard clauses: simulate runtime typing of subroutine arguments.

Subroutines as constants

There are no constant variables in Perl.
Instead, one uses subroutines.
```
 
sub pi { 3.1415929 } 
sub pies { 20 } 
sub flavor { 'lemon merangue' }
```
declares some numeric and string constants &pi, &pies, and &flavor, with appropriate values.
can be freely used in expressions.
Perl is smart enough to do constant folding on constant subroutines at compile-time, treating them like variables.
E.g., perl will rewrite:
```
 $p = &pies * 40; 
```
as
```
$p = 800;
```
during compilation, i.e., before actual execution.

Prototypes

Can't declare subroutine arguments.
Can declare their types.
Basic syntax
```
 
sub (proto) { 
    ...
} 
```
where Proto contains a sequence of characters and two character sequences starting with \, to wit:
- $: a scalar (including all predefined references).
- \$: a scalar variable that will automatically be converted to a reference during the invocation (and is not a reference within the argument list).
- @ : an array (must be last).
- \@: an array variable that will automatically be converted to a reference.
- % :a hash table (must be last).
- \%: a hash variable that will automatically be converted to a reference.
- * : a typeglob, filehandle, or other type.
- & : a function or function block.
Watch out!
- Prototypes change calling semantics for a subroutine.
- They are invoked in certain circumstances and ignored in others.

Consider:

contents of perl_decl/proto1.pl...
#! /var/local/couch/bin/perl 

sub printAddr (\@$$) { 
   my ($addr,$name,$phone) = @_; 
   print "name=$name\n"; 
   print "phone=$phone\n"; 
   print "addr=@$addr\n"; 
} 

@addr = ('1600 Pennsylvania Ave', 'Washington', 'DC'); 
# invoke prototype
printAddr @addr, 'George Bush', '555-1212'; 
# override prototype
&printAddr(@addr,'George Bush', '555-1212'); 
...end of perl_decl/proto1.pl

This prints:

contents of perl_decl/proto1.pl.out...
name=George Bush
phone=555-1212
addr=1600 Pennsylvania Ave Washington DC
name=Washington
phone=DC
addr=
...end of perl_decl/proto1.pl.out

In the first invocation, $addr is set to \@addr from outside, so its value is ['1600 Pennsylvania Ave', 'Washington', 'DC'].
In the second invocation, the prototype is ignored. This flattens the argument list (as usual) into
```
('1600 Pennsylvania Ave', 'Washington', 'DC', 'George Bush', '555-1212')
```
and then the first argument of
```
(@addr,$name,$phone)=@_
```
consumes everything, leaving $name and $phone empty.

Example: emulating behavior of `sort`

Consider:

contents of perl_decl/apply.pl...
#! /var/local/couch/bin/perl 

# this subroutine emulates LISP's apply, by applying a 
# function to a list of arguments. 

sub apply (&$) { 
    my $func = shift; 
print "func=$func\n" ; 
    $_ = shift; 
print "\$_=$_\n" ; 
    &{$func}; 
} 

$foo =  apply { $_*3 } 4; 
print "foo=$foo\n"; 
...end of perl_decl/apply.pl

This prints:

contents of perl_decl/apply.pl.out...
func=CODE(0x8117b2c)
$_=4
foo=12
...end of perl_decl/apply.pl.out

Attributes

Can also declare attributes of subroutines (and, for now, variables as well (experimental)).
An attribute of a subroutine is something like a pragma in C++. It encodes something about the function
Three meaningful attributes:
- :lvalue: function returns a location to which something can be assigned.
- :locked: in a multithreaded environment, only allow one instance of this subroutine to execute at a time.
- :locked :method: in a multithreaded environment, only allow one instance of this subroutine to be active per object upon which it operates (more about this later).

Consider the code:

contents of perl_decl/lvalue1.pl...
#! /var/local/couch/bin/perl 

$systime=0; 
$usertime=0; 
# works correctly
sub whichToChange :lvalue { shift==0 ? $systime : $usertime; } 
whichToChange($<)=7;
print "systime=$systime usertime=$usertime\n"; 
...end of perl_decl/lvalue1.pl

This produces:

contents of perl_decl/lvalue1.pl.out...
systime=0 usertime=7
...end of perl_decl/lvalue1.pl.out

Watch out! This code is very finicky. Even adding a return statement messes it up by making a copy of the reference. E.g.,

contents of perl_decl/lvalue2.pl...
#! /var/local/couch/bin/perl 

$systime=0; 
$usertime=0; 
# non-functional!
sub whichToChange :lvalue { 
    if (shift==0) { return $systime }
    else { return $usertime; } 
} 
whichToChange($<)=7;
print "systime=$systime usertime=$usertime\n"; 
...end of perl_decl/lvalue2.pl

doesn't compile.

Value-based scoping

One really strange feature of Perl: some values can be assigned attributes that determine scoping of names.
This only applies to references.
Key to this is the operator bless

`bless`

bless $ref,$package: assert that the value of $ref is a member of the package $package.
Default package is the current one.
The purpose of bless is to define a scope for function applicability to the value.

Definition: if

bless $var,'Goo';

then

$var->something(@args)

means (is translated into)

&Goo::something($var,@args)

In other words, the blessing of a value determines which function is called on that value, and serves as a scoping mechanism for function namespaces.
This is the basis of "Perl Object-Oriented Programming".
It is a bit of a misnomer. It implements "object polymorphism" but not true OO programming.
After bless $var,'Goo', ref($var) is 'Goo'.
One other shorthand we need: the notation
```
func Package(@args)
```
means (is translated into)
```
&Package::func('Package',@args)
```

Consider:

contents of perl_decl/bless1.pl...
#! /var/local/couch/bin/perl 

# represent a named Complex number
package Complex ; 
sub new { 
    my $p = shift; 
    bless { 'label'=>$_[0],'re'=>$_[1], 'im'=>$_[2] }, $p;
} 
sub label:lvalue { $_[0]->{'label'} } 
sub re:lvalue { $_[0]->{'re'} } 
sub im:lvalue { $_[0]->{'im'} } 
sub printLabel { ref($_[0]) . " " . $_[0]->label } 
sub print { 
    my $self = shift; 
    print ref($self) . " " . $self->label 
          . " (real=" . $self->re
          . ", imag=" . $self->im . ")\n"; 
} 

package main; 

$thing = new Complex("Fred", 1.0, 2.0); 
# or &Complex::new('Complex',"Fred", 1.0, 2.0) 

use Data::Dumper; 
print Dumper($thing); 

$thing->print; 
$thing->re=3.7; 
$thing->print; 
$thing->label='George'; 
$thing->print; 
print Dumper($thing); 
...end of perl_decl/bless1.pl

This prints:

contents of perl_decl/bless1.pl.out...
$VAR1 = bless( {
                 're' => '1',
                 'im' => '2',
                 'label' => 'Fred'
               }, 'Complex' );
Complex Fred (real=1, imag=2)
Complex Fred (real=3.7, imag=2)
Complex George (real=3.7, imag=2)
$VAR1 = bless( {
                 're' => '3.7',
                 'im' => '2',
                 'label' => 'George'
               }, 'Complex' );
...end of perl_decl/bless1.pl.out

The variable $thing knows its type, and that type determines which functions will be called on it using the arrow notation.

Object polymorphism

Make a list of things.
Each thing has methods.
Appropriate method is called for each type.

Consider

contents of perl_decl/bless2.pl...
#! /var/local/couch/bin/perl 

# represent a Point in the plane
package Point; 
sub new { my $p = shift; bless { @_ }, $p } # cast to associative array
sub name:lvalue { $_[0]->{'name'} } 
sub printName { ref($_[0]) . " " . $_[0]->name } 
sub area { 0 }; 
sub x:lvalue { $_[0]->{'x'} }
sub y:lvalue { $_[0]->{'y'} }

# represent a Circle in the plane.
package Circle; 
sub new { my $p = shift; bless { @_ }, $p } # cast to associative array
sub name:lvalue { $_[0]->{'name'} } 
sub printName { ref($_[0]) . " " . $_[0]->name } 
sub x:lvalue { $_[0]->{'x'} }
sub y:lvalue { $_[0]->{'y'} }
sub radius:lvalue { $_[0]->{'radius'} }
sub PI { 3.1415929 }
sub area { &PI * $_[0]->{'radius'} * $_[0]->{'radius'} } 

# represent a Rectangle in the plane
package Rectangle; 
sub new { my $p = shift; bless { @_ }, $p } # cast to associative array
sub name:lvalue { $_[0]->{'name'} } 
sub printName { ref($_[0]) . " " . $_[0]->name } 
sub x1:lvalue { $_[0]->{'x1'} }
sub y1:lvalue { $_[0]->{'y1'} }
sub x2:lvalue { $_[0]->{'x2'} }
sub y2:lvalue { $_[0]->{'y2'} }
sub area { abs(($_[0]->{'x1'}-$_[0]->{'x2'})*($_[0]->{'y1'}-$_[0]->{'y2'})); } 

package main; 

@stuff = ( 
   new Point ("name"=>"Fred", "x"=> 1, "y"=>2), 
   new Rectangle ("name"=>"George", "x1"=>0, "y1"=>0, "x2"=>2, "y2"=>3), 
   new Circle ("name"=>"Amy", "x"=>3, "y"=>3, "radius"=>2)
); 

use Data::Dumper; 
print Dumper(\@stuff); 

for my $s (@stuff) { 
   print $s->printName . " area is " . $s->area . "\n"; 
} 
...end of perl_decl/bless2.pl

This prints:

contents of perl_decl/bless2.pl.out...
$VAR1 = [
          bless( {
                   'y' => 2,
                   'name' => 'Fred',
                   'x' => 1
                 }, 'Point' ),
          bless( {
                   'y1' => 0,
                   'x2' => 2,
                   'name' => 'George',
                   'y2' => 3,
                   'x1' => 0
                 }, 'Rectangle' ),
          bless( {
                   'y' => 3,
                   'radius' => 2,
                   'name' => 'Amy',
                   'x' => 3
                 }, 'Circle' )
        ];
Point Fred area is 0
Rectangle George area is 6
Circle Amy area is 12.5663716
...end of perl_decl/bless2.pl.out

In a list of several objects:
- Each object "remembered its own type".
- Each object "called the appropriate area method".

Real meaning of polymorphism

Seems like an object-oriented programming method.
In actuality, a form of runtime type checking.
If you call a subroutine relative to a blessing, and no subroutine exists, it is a runtime error.

Inheritance

Note that in the above example, several methods are identical over all objects.
This means, in Perl, that these methods can be inherited.

Let's make up a base object that contains those methods, and inherit them:

contents of perl_decl/bless3.pl...
#! /var/local/couch/bin/perl 

# represent an arbitrary object in the plane
package Thing; 
sub new { my $p = shift; bless { @_ }, $p } # cast to associative array
sub name:lvalue { $_[0]->{'name'} } 
sub printName { ref($_[0]) . " " . $_[0]->name } 
sub area { 0 } # default area is 0

# represent a Point in the plane
package Point; 
@Point::ISA = ('Thing'); # inherit methods
sub x:lvalue { $_[0]->{'x'} }
sub y:lvalue { $_[0]->{'y'} }

# represent a Circle in the plane.
package Circle; 
@Circle::ISA = ('Thing'); # inherit methods
sub x:lvalue { $_[0]->{'x'} }
sub y:lvalue { $_[0]->{'y'} }
sub radius:lvalue { $_[0]->{'radius'} }
sub PI { 3.1415929 }
sub area { &PI * $_[0]->{'radius'} * $_[0]->{'radius'} } 

# represent a Rectangle in the plane
package Rectangle; 
@Rectangle::ISA = ('Thing'); # inherit methods
sub x1:lvalue { $_[0]->{'x1'} }
sub y1:lvalue { $_[0]->{'y1'} }
sub x2:lvalue { $_[0]->{'x2'} }
sub y2:lvalue { $_[0]->{'y2'} }
sub area { abs(($_[0]->{'x1'}-$_[0]->{'x2'})
              *($_[0]->{'y1'}-$_[0]->{'y2'})); } 

package main; 

@stuff = ( 
   new Point ("name"=>"Fred", "x"=> 1, "y"=>2), 
   new Rectangle ("name"=>"George", "x1"=>0, "y1"=>0, "x2"=>2, "y2"=>3), 
   new Circle ("name"=>"Amy", "x"=>3, "y"=>3, "radius"=>2)
); 

use Data::Dumper; 
print Dumper(\@stuff); 

for my $s (@stuff) { 
   # print Dumper($s); 
   print $s->printName . " area is " . $s->area . "\n"; 
} 
...end of perl_decl/bless3.pl

This works identically to the above example.

@ISA=('Thing'): inherit all methods from package Thing.
No concept of data inheritance at all!

Whoa there!

Inheritance (@ISA) is a dynamic package parameter.
Can change inheritance relationships between packages on the fly, or even shadow them with local variables.
"Object-disoriented" programming?

Simulating data inheritance

Note that in the above, I expose several values of objects as :lvalue subroutines.
This is the only way to implement a data element of an object!
To do this, I had to know the following:
- @_ is an array of references.
- So if one changes it, one changes the outside world.
- :lvalue forces my subroutine to return a reference.
- So changing changes the thing that I returned.
- One must take care not to even use return in returning a reference (it copies the value).
- Return values must be direct references to @_.

Summary of visibility operations

my, our, local control data visibility.
bless controls function visibility, i.e., "makes functions bound to the data upon which they operate".
using function attribute :lvalue, function visibility can simulate data visibility.
using references to function, data visibility can simulate function visibility.
function prototypes implement a primitive type-checking mechanism, but only check whether arguments are scalars, arrays, hashes, or functions.

Guard clauses

Function prototypes aren't really a type-checking mechanism for parameters.
There is no real concept of function prototyping as in C++.
Type checking only exists for object methods.
Instead, one must use runtime prototyping.
Subroutines utilize guard clauses that validate subroutine inputs as reasonable.
If an input isn't reasonable, die with your own personal runtime error.

Consider the code:

contents of perl_decl/bless4.pl...
#! /var/local/couch/bin/perl 

# represent an arbitrary object in the plane
package Thing; 
sub new { my $p = shift; bless { @_ }, $p } # cast to associative array
sub name:lvalue { $_[0]->{'name'} } 
sub printName { ref($_[0]) . " " . $_[0]->name } 

# represent a Point in the plane
package Point; 
@Point::ISA = ('Thing'); # inherit methods
sub area { 0 }; 
sub x:lvalue { $_[0]->{'x'} }
sub y:lvalue { $_[0]->{'y'} }
sub print { 
    my $self = shift; 
    print ref($self) . " " . $self->name 
          . " (x=" . $self->x 
          . ", y=" . $self->y . ")\n"; 
} 

# represent a Circle in the plane.
package Circle; 
@Circle::ISA = ('Thing'); # inherit methods
sub x:lvalue { $_[0]->{'x'} }
sub y:lvalue { $_[0]->{'y'} }
sub radius:lvalue { $_[0]->{'radius'} }
sub PI { 3.1415929 }
sub area { &PI * $_[0]->{'radius'} * $_[0]->{'radius'} } 
sub print { 
    my $self = shift; 
    print ref($self) . " " . $self->name 
          . " (radius=" . $self->radius  
	  . ", x=" . $self->x 
          . ", y=" . $self->y . ")\n"; 
} 
sub inside { 
    my $self = shift; 
    die "improper input " . ref($self)  . " to Circle::inside"
	if ref $self ne 'Circle'; 
    my $point = shift; 
    die "improper argument to Circle::inside" 
	if ref $point ne 'Point'; 
    die "too many arguments to Circle::inside" 
	if @_ != 0; 
    my $d = sqrt( 
	($point->x-$self->x)*($point->x-$self->x) 
      + ($point->y-$self->y)*($point->y-$self->y) 
    ); 
    return 1 if $d < $self->radius; 
    return undef; 
} 

package main; 

use Data::Dumper; 
$circ = new Circle ('name'=>'Amy', 'x'=>3, 'y'=>3, 'radius'=>2); 
$point = new Point ('name'=>'Marsha', 'x'=>2, 'y'=>3); 
print $point->printName . '=' . Dumper($point); 
print $circ->printName . '=' . Dumper($circ); 
if ( $circ->inside($point)) { 
    print $point->printName . " is inside " . $circ->printName . "\n"; 
} else { 
    print $point->printName . " is not inside " . $circ->printName . "\n"; 
} 
if ( $circ->inside(3,4)) { 
    print $point->printName . " is inside " . $circ->printName . "\n"; 
} else { 
    print $point->printName . " is not inside " . $circ->printName . "\n"; 
} 
...end of perl_decl/bless4.pl

This prints:

contents of perl_decl/bless4.pl.out...
Point Marsha=$VAR1 = bless( {
                 'y' => 3,
                 'name' => 'Marsha',
                 'x' => 2
               }, 'Point' );
Circle Amy=$VAR1 = bless( {
                 'y' => 3,
                 'radius' => 2,
                 'name' => 'Amy',
                 'x' => 3
               }, 'Circle' );
Point Marsha is inside Circle Amy
improper argument to Circle::inside at bless4.pl line 42.
...end of perl_decl/bless4.pl.out

Clauses inside each subroutine validate input before proceeding with the subroutine.

lecture in color

downloaded on Mar-16-2010 12:08:08 PM,
was last modified on Dec-31-1969 07:00:00 PM.
All lecture note content is copyright 2003 by
Alva L. Couch, Computer Science, Tufts University
(couch at cs dot tufts dot edu)

Localizing globals

Caveat: separation of method and discipline

Localization of binding

Kinds of localization of binding

Packages

Why use a package?

Declarations (PP chapter 4)

my $var;

our $var;

local $var;

Shadowing

Scoping demonstration

Why scoping?

Basic 'rule of scope'

use strict

Simulating other kinds of declarations

Subroutines as constants

Prototypes

Example: emulating behavior of sort

Attributes

Value-based scoping

bless

Object polymorphism

Real meaning of polymorphism

Inheritance

Whoa there!

Simulating data inheritance

Summary of visibility operations

Guard clauses

`my $var;`

`our $var;`

`local $var;`

`use strict`

Example: emulating behavior of `sort`

`bless`