COMS 3101 Programming Languages: Perl. Lecture 6

Transcription

1 COMS 3101 Programming Languages: Perl Lecture 6 Fall 2013 Instructor: Ilia Vovsha

2 Lecture Outline Concepts: Subroutine references Symbolic references Saving structures OOP (inheritance) More on modules: CPAN Prgamas: fields, base Module: Class::Struct Pod (plain old documentation) Common remarks 6.2

3 Concepts Subroutine references Copying referent Symbolic references Saving structures 6.3

4 Subroutine References Reference to a sub follows similar rules Can use backslash or anonymous sub max {. } # Anonymous $sub_ref = \&max; $sub_ref = sub {. }; # Calling subroutine &$sub_ref(); $sub_ref > (); $sub_ref > (1,4,6,8); # Call sub using string my %cmds = ( process => \&process_data, clear => \&clear_data, any => sub {.} ); $cmds{$str} > (); 6.4

5 Copy Referent To copy referent for another reference: $aref1 = [ 1,2,3 ]; $aref2 = [ 4,5,6 ]; $aref2 = $aref1 $aref2 = ]; $href2 = { %{$href1 } }; # Not a copy! Rather refers to the same location! # Create a new anonymous reference # Same approach for hashes 6.5

6 Symbolic References Refers to the name of a variable If we try to dereference, we get access to variable! Can be dangerous! (use strict refs to prohibit) $N = V ; $$N = 5; # Set scalar $V = 5 $N > [0] = 6; # Set element 0 of array V to 6 $N > {key} = 7; # Set key of hash V to 7 &$N; # Call sub V 6.6

7 Saving Data Structures Save any DS to use later: Data::Dumper module Turn DS into a string, save externally to a file, read in the file and recover DS with eval / do CPAN module Storable: more efficient, but cannot be shared across different architectures use Data::Dumper; open (OUTFILE, > filename ); print OUTFILE Data::Dumper >Dump([\%hash], [ *hash ]); open (INFILE, < filename ); undef $/; # undef record separator, read entire file eval <INFILE>; # recreate %hash use Storable; store(\%hash, filename ); $href = retrieve( filename ); %hash = % { retrieve( filename ) } ; 6.7

8 OOP (inheritance) We can define a hierarchy of classes to share methods between them Derived d/ sub class inherits i methods from base / parent / super class The super classes are specified in array (declared with our) of the derived class. Each element of the array is a package (class) name Single Inheritance: one parent class (search parent for methods) Multiple Inheritance: multiple parent classes (search left to right array, depth first order) Once method is found, store in cache for efficiency is changed, the cache is invalidated (avoid it if you can!) Constructor Inheritance: no automatic call to base class constructor 6.8

9 OOP (method search) If method not defined in class: at runtime when a call is made Search order given multiple l parent classes: lftt left to right ihtthrough array, depth first # Nissan.pm package Nissan; = (Car, Truck); # Call: Nissan >new() >build( sedan ); # Search order: 1. Check if method (build) is defined in class (Nissan) 2. Check if method is defined in $Nissan::ISA[0] (Car class) 3. Check if method is defined (Car array) 4. When done with ISA[0], repeat steps 2,3, for ISA[1] (Truck class) 6.9

10 Scoped Variables my creates private variable visible only within block hidden from outside of enclosing scope, and hides previously declared variables with identical name confines name & value to scope suitable for scalar/array/hash variables our confines name only to scope (no effect on visibility) suitable for scalar/array/hash variables used to access global variables, their initial value inside block unchanged effects or assignmentpersist after the scope of declaration (block) local confines value only to scope suitable for scalar/array/hash + more variables initial value for variable is () or undef value of variable is restored no matter how you exit the block (changes thrown away) dynamic scope: value of variable depends on scope & changes during run time my is preferable over local APP

11 Scoped Variables (example) $office = "global"; &say(); &barney(); &fred(); &say(); sub say { print "$office\n"; } # Global $office # prints "global" # prints "barney global", lexical scope; # prints "fred fred", dynamic scope, # prints "global", restored after &fred() # print the $office sub barney { my $office = "barney"; print "$office "; &say(); } sub fred { local $office = "fred"; print "$office "; &say(); } APP

12 CPAN Comprehensive Perl Archive Network: repository for modules Installing a module: # Download the.gz file from CPAN, unzip and go to proper directory # Build: perl MakeFile.pl make make test # Install: make install Alternative: install cpanm module cpan App::cpanminus # Install cpanm cpanm Module::Name # get, unpack, build, and install modules 6.12

13 Method invocation (indirect) Direct approach: arrow operator INVOCANT >METHOD() Indirect approach: can be ambiguous METHOD INVOCANT ARGS $mazda = Car > new(); $mazda > drive( slow ); $mazda = new Car; drive $mazda slow ; # Class: Car, Method: new, Object: $mazda # Instance: $mazda, Method: drive # Same as above 6.13

14 Pseudohashes (deprecated!) Pseudohash: reference to array whose 1 st element is reference to hash Purpose: can be treated t as array ref or hash href Deprecated: slower, muddling, problems with multiple inheritance Alternatives: restricted hashes (Hash::Util) $ph_ref = [ {maker => 1, color => 2}, mazda, red ]; # Definition $ph_ref >{color}; # Access element (href) $ph_ref ref >[2]; # Access element (aref) $ph_ref >[0]{cost} = 3; $ph_ref >[3] = cheap ; # Add element 6.14

15 fields pragma Experimental feature, enables compile time type verified class fields Note: pseudohashes h removed from perl The related base pragma provides for field inheritance from parent class fields::new() creates and blesses a pseudohash comprised of the fields declared using the fields pragma into the specified class. package Car; package Car; use fields qw(maker color cost); sub new { my $class = shift; sub new { my $self = { my $class = shift; maker => mazda, my $self = fields::new($class); color => red, cost => $self >{maker} = mazda ; }; $self >{color} = red ; bless ($self, $class); return $self; return $self; } } 6.15

16 fields pragma (example) Prevents typos in field names (otherwise accepted): package Car; use fields qw(maker color cost); sub new { my $class = shift; my $self = fields::new($class); $self >{maker} = mazda ; $self >{color} = red ; return $self; } sub some_fun { my $self = shift; $self >{colour} = blue ; } # Compiler throws error! 6.16

17 base pragma Simplifies inheritance in two ways: Assigns without having to declare Inherits fields of parent class if fields pragma is used Problem: multiple inheritance is not supported! (raises exception if more than one base class uses fields ) package Mazda; use base qw(car); use fields qw(vehicle mpg); sub new { my $class = shift; my $self = fields::new($class); l $self >{maker} = mazda ; $self >{mpg} = 25; return $self; } # Mazda is subclass of Car # Inherits fields from Car class, adds two new fields # inherited # own attribute 6.17

18 Class::Struct module Standard module to declare a record like class struct t function provides for constructor t and accessor methods on the fly Constructor named new Accessor method for each member specified by the hash reference package Car; use Class::Struct; struct Car => { name => $, # Scalar variable ibl size # array variable specs => %, # hash variable } 1; type => Truck, # Truck object use Car; $kia = Car > new(); $kia > name( CX5 ); $aref = $kia >size; $kia > size(0,100); $href = $kia >specs; $kia > specs( color, white ); 6.18

19 Pod Plain Old Documentation: simple text markup format Simple to use, not too expressive Embed documentation in Perl modules and scripts Translators: convert Pod to various formats pod2text, pod2html, pod2latex Content tdivided id d into paragraphs by empty lines: verbatim: begins with tabs/spaces (left unformatted) command: begins with equal sign (format according to directive) ordinary: begins with something else (minimal formatting) Perl engine throws out all Pod markup 6.19

20 Pod (example) =head1 Boring Module Synopsis Some I<boring> text about the module followed by even more B<boring> code =cut use Boring ; my $object = Boring >new(); sub some_fun { print Documentation ; print is for old people!\n ; } =pod 6.20

21 Pod (example ctd) =head2 List of methods =over 4 =item 1. First method enforces mild boredom =item 2. Second method puts you to sleep =back 6.21

22 Exercise (In Class) Remove specific field from a list Suppose you have a row of data stored in a string. The fields of your row may be separated with any delimiter(s). For example: Name Height Weight 2. Write a subroutine that deletes the Nth field (N is an argument), and returns the shortened string. 6.22

23 Common Remarks Filehandles: open($fh, >filename ); print $fh ABC, \t, DEF ; # works fine print $fh, ABC, \t, DEF ; # WRONG: prints to STDOUT Context: ($x) = (aa,bb,cc); # $x gets value aa $x = (aa,bb,cc); # $x gets value = (aa,bb,cc); $x # $x =

24 Common Remarks Efficiency: hashes instead of linear searches # Search $word # Method 1: foreach (@keywords) { print yes if ($word eq $) $_); } # Method 2 (potentially more efficient): %h; for (@keywords) { $h{$_}++; } print yes if ($h{$word} > 0); 6.24

25 Common Remarks Efficiency: print with comma not. print Mr., $name, is next ; print Mr.. $name. is next ; # faster Db Debugging is problematic: use warnings Planning to share code: use strict 6.25

26 Error Handling Relevant functions: Build in: warn, die Carp module: carp, cluck, croak, confess Choosing the proper function: Raise a warning and then continue or terminate execution? What should the error message report? filename & line number / caller s info open($fh, fname ) or warn Warning Message ; open($fh, fname ) or die Warning Message ; # warn: just a warning, message printed to STDERR # die: similar to warn, but also calls exit (terminates execution) 6.26

27 Error Handling (in modules) Carp module: use Carp Debugging a module: report module s name & line number (warn, die) Debugging the script: report caller s info (carp / cluck, croak / confess) package Job; use Carp; sub some_fun { warn Error ; # carp Error ; # croak Error ; # cluck Error ; } 1; # confess Error ; use Job; Job::some_fun(); # Prints the following: # warn: Error at Job.pm line 5. # warn: Error at test.pl line 3. # die: Error at test.pl line 3. # warn: Error at Job.pm line 5. # Job::some_fun() called at test.pl line 3. # die: Error at Job.pm line 5. # Job::some_fun() called at test.pl line