Programming in perl style

Program in Perl Style Reference

David Young
yangboh@cn.ibm.com
Feb. 2011


Reference – the awesome reference


What can we do with reference?
Dispatch table
Higher order functions

In computer science, a dispatch table is a table of pointers to functions or
methods. Use of such a table is a common technique when implementing
late binding in object-oriented programming.


Dispatch table
# define your functions # Push them into hash table
%dispatch = {
sub hellow { ”hellow” => &hellow,
”foo” => $foo,
print ”hellow world”;
“bar” => sub {
} print ”bar foon”;
},
}

$foo = sub {

print ”foo world”;

}

To be continued ...


Dispatch table - continued
# dispatch tasks from your hash table
$a = ”hellow”;
&${dispatch->{$a}}();
# hellow world
# This is your hash table

$rb = $dispatch->{”foo”}; %dispatch = {
&$rb(); ”hellow” => &hellow,
”foo” => $foo,
# foo world “bar” => sub {
print ”bar foon”;
},
$rc = $dispatch->{”bar”}; }

&$rc;
# bar foo


Reference – the awesome reference
Dispatch table
Higher order functions

In mathematics and computer science, higher-order functions, functional forms, or
functionals are functions which do at least one of the following:

* take one or more functions as an input
* output a function.


Higher Order Functions
sub category_defect {
Local $_; # just for a good habit
my ( $column ) = @_;
return sub { # return a function instead a value
my ( $condition, $line ) = @_;
return $$line[ $column ] eq $condition ;
}
}


sub defect_by_category {
local $_;
my ($column, $col_value) = @_;
my $category = &category_defect( $column ); # which return
return sub { # a function
my (@result);
my ($defect) = @_;
return $defect # invoke previous function
if &$category ($col_value, $defect) ;
}
}


sub defects_factory {
local $_;
my ($defect, @results); # accept function as param
my ($conditions, $defects ) = @_;
foreach $defect ( @$defects ) {
push @results, $defect if &$conditions ( $defect );
}
return @results;
}


# $severity_1 holds a function reference, not a ordinary data

$severity_1 = &defect_by_category( SEVERITY, "1" );




# transfer a function reference as parameter

@severity_1 = &defects_factory( $severity_1 , [ @defects ] );




Program in Perl Style Typeglobs

Typeglob is complex and dangures
Always be careful!!!


Typeglobs and symble table
–– You'd better to read Camel book very carefully
before start to using it.
$spud = "Wow!";

@spud = ("idaho", "russet");

*potato = *spud; # Alias potato to spud using typeglob assignment

print "$potaton"; # prints "Wow!"

print @potato, "n"; # prints "idaho russet"


It is NOT the pointer you would expect in C
although they look similar literally
$b = 10;

{

local *b; # Save *b's values

*b = *a; # Alias b to a

$b = 20; # Same as modifying $a instead

} # *b restored at end of block

print $a; # prints "20"

print $b; # prints "10"


Efficient parameter passing
@array = (10,20);

DoubleEachEntry(*array); # @array and @copy are identical.

print "@array n"; # prints 20 40

sub DoubleEachEntry {

# $_[0] contains *array

local *copy = shift; # Create a local alias

foreach $element (@copy) {

$element *= 2;

}

}


Passing Filehandles to Subroutines
Filehandle can not be passed to subroutines as scalars
The only way to it is through typeglobs

open (F, "/tmp/sesame") || die $!;
read_and_print(*F);

sub read_and_print { # Filehandle G
local (*G) = @_; # is the same as filehandle F
while (<G>) { print; }
}


Typeglobs are not always so explicitely
cat test.pl
#!/usr/bin/perl Be very careful!!!
$foo = 123;
Implicit typeglobs will make
$bar = 321;
your code very hard to
$ra = "foo";
print "$ra = $$ra n"; understand
while ($rb = <STDIN>) {
chomp($rb);
print "$rb = $$rb n";
} bash-4.1$ echo "bar" | perl test2.pl
foo = 123
bar = 321


But anyway ---- It's powerful!!!


You can even build dispatch table from a plain file
cat a.cfg while ($a = <>) {

h say_hellow_to_a_friend chomp($a);

($key, $func) = split ” ”, $a;
a accept_an_invitation
$disptch{$key} = $func;
c confirm_an_invition
}
e send_email_to_a_friend
r refuse_an_invitation sub command {

my ($cmd, arg) = @_;

Suppose you have functions $rcmd = $disptch->{$cmd};

in above names &$rcmd($arg) if defined &$rcmd;

}

&command("h", ”Tom”);

Program in Perl Style

Say good-bye to your endless ...
switch ...
case ...
if elsif ...
etc.
So think again why there is no 'switch',
'case' ... in Perl?
Maybe you don't actually need it.

Programming in perl style

More Related Content

What's hot (20)

Similar to Programming in perl style (20)

Recently uploaded (20)

Programming in perl style