CS 3101 _ programming languages (perl)

Transcription

1 CS 3101 _ programming languages (perl) Fall 2008 CS Department - Columbia University Nov 10 th 2008

2 Today Perl Functions References Subroutines Introduction to Object Oriented Perl Assignment 2 2

3 A Few More Functions Part I

4 One more quoting operator qw// Takes a space separated sequence of words, and returns a list of single-quoted words. no interpolation = qw/cat dog bird ('cat', 'dog', 'bird', 'mouse'); As with q//, qq//, qx//, m//, and s///, you may choose any non-alphanumeric character for the delimiter. 4

5 map (EXPR BLOCK) LIST evaluate EXPR (or BLOCK) for each value of LIST. Set $_ to each value of LIST, much like a foreach loop Returns a list of all results of the expression = map {split(' ', for each element (alias the element to $_), run split(' ', $_), push results Equivalent: foreach (@lines) { split(' ', $_); } 5

6 More map examples = qw/morning afternoon night/; = map ("Good morning", "Good afternoon", "Good night") = (1..5); = map {$_ (2, 4, 6, 8, 10); If you use a block, there is no comma separating the args. If you use an expression, there is. 6

7 grep (EXPR BLOCK) LIST Similar concept to map (and same syntax) returns a list of all members of the original list for which expression was true. (map returns list of all return values of each evaluation) Pick out elements you want to = grep picks out all lines beginning with comments Assigns $_ to each member then evaluates the pattern match. If pattern match is true, $_ is = grep { $_ % 2 == = grep { length > 9 7

8 grep = grep for (@lines){ if (/^\s*#/){ $_; } } 8

9 each Pick out keys and values from a hash. In scalar context, just gets the next key: while (my $key = each %hash){...} foreach my $key (keys %hash){...} In list context, gets the next key and value of the hash. while (my ($key,$val)= each %hash) {...} foreach my $key (keys %hash) { my $val = $hash{$key}; #... } If your list contains more than 2 variables, others get assigned to undef Will return key/val in same "random" order as keys() and values() 9

10 glob EXPR returns EXPR after it has passed through Unix filename expansion. as evaluated by the csh shell In Unix, ~ is a wild card that means "home directory of this user" ie, my home directory is ~vk2199/ Other wildcards: * 0 or more of any character? exactly one of any character. Fails: opendir my $dh, '~vk2199 '; Works: opendir my $dh, glob ~vk2199 '; 10

11 glob returns In list context, returns all files/directories that fit the pattern of the wildcard expansion. = glob ('*.pl'); gets a list of all files with a.pl extension in the current directory. In scalar context, returns the "next" file/directory that fits the pattern. After last entry, will return undef before returning first entry again. while (my $file = glob ('*.txt'){ print "file = $file\n"; } Special <*> operator uses glob internally while (my $file = <*.txt>) { } 11

12 eval EXPR evaluate perl code. Code is parsed and executed at run-time. This is considered highly dangerous by some people, and causes some to warn people away from eval altogether. my $x; my $foo = q{$x = 'hello';}; eval $foo; #$x now set to 'hello' 12

13 eval BLOCK evaluate perl code Code is parsed at compile time This is perl's method of exception handling. Fatal errors are trapped, errors stored in eval { $x = $y / $z; }; warn "Exception caught: $@" if $@; Both perl errors, and your own die() calls are caught. 13

14 undef & defined undef undefines its argument Also returns undefined value. $foo = undef; #works undef $foo; = undef; #doesn't work!! = (); #preferred undef can be used to throw away unneeded values: ($foo, undef, $bar) = fctn(); defined returns true if argument is not undef. Returns false otherwise. my ($foo, $bar) = (5); print "Foo is undef\n" if!defined $foo; print "Bar is undef\n" if!defined $bar; 14

15 delete & exists delete removes a key/value pair from a hash my %foo =(one=>1, junk=>-999, two=>2); delete $foo{junk}; %foo (one=>1, two=>2); (contrast with undef $foo{junk} ) Can be used with arrays, but doesn't do the same: = ('a'..'e'); delete ('a', 'b', undef, 'd', 'e') will shrink array if the deleted element is last exists returns true if the key exists in the hash: print "%foo has a value at 'one'\n" if exists $foo{one}\n"; (contrast with defined $foo{one} ) 15

16 status of hash elements hash value true value is defined, key exists. hash value defined key exists, value may be false. hash key exists value may be false, may be undef if (exists $hash{$key}){ if (defined $hash{$key}){ if ($hash{$key}){ print "$hash{$key} is true\n"; } else { print "$hash{$key} is false\n"; } } else { print "$key exists, value undef\n"; } } else { print "$key does not exist in hash\n"; } 16

17 our 'declares' a global variable to be used within the smallest enclosing block. Within the block, the global variable does not need to be fully qualified. Obviously, only has any meaning if strict is being used. our $foo; Can now use $main::foo just by saying $foo. Still no reason to do this - file-scoped lexicals are all you need. until Object Oriented Perl 17

18 References Part II

19 References Analagous (somewhat) to pointers in C/C++ Far less messy, and definitely less dangerous You can take a reference to any variable - array, hash, or scalar. The reference itself is a scalar. Use the \ to create a reference: = (1, 2, 3); my $aref = \@foo; $aref now contains a reference to the Changes will affect array referenced by $aref Changes to the array referenced by $aref will 19

20 De-Referencing De-reference a reference by enclosing it in { } and prepending the appropriate symbol hash %, scalar $) $aref = contents of { } a simple scalar can can be used like any other array: 'val1', is a different array, which is initialized with the values that the array referenced by $aref contains. same as if you'd Changes or $aref do NOT Changes DO 20

21 Referencing Other Types You can also take references to other kinds of variables: my %age_of = (Paul=>29, Tom=>20); my $href = \%age_of; my $bar = "hello world\n"; my $sref = \$bar; To dereference, %{$href} and ${$sref} 21

22 Anonymous References A value need not be contained in an existing variable to create a reference. To create an anonymous array reference, use square brackets, instead of parens my $arr_ref = [20, 30, 50, "hi!!"]; = (20, 30, 50, "hi!!"); For hash references, use curly brackets $h_ref = {sky=>'blue', grass=>'green'}; my %color_of = %{$h_ref}; %color_of (sky => 'blue', grass => 'green'); There is no "clean" way to create an anonymous scalar ref: my $s_ref = do { my $x; \$x; }; 22

23 Elements of Referenced Values TIMTOWTDI my $a_ref = ['Hi', 'Hiya', ('Hi', 'Hiya', 'Hello') ${$a_ref}[2] 'Hello' $$a_ref[2] 'Hello' #simple scalar $a_ref->[2] 'Hello' my $h_ref = {foo=>'bar', alpha=>'beta'}; %{$h_ref} (foo=>'bar', alpha=>'beta') ${$h_ref}{foo} 'bar' $$h_ref{foo} 'bar' #simple scalar $h_ref->{foo} 'bar' These are all valid and acceptable. The form you choose is whatever looks the best to you. I personally prefer the arrow notation. It looks cleaner to me. 23

24 Uses for References To create a 2D array, create an array of array references: = ([1, 2], [3, 4], [5, 6]); $two_d[1] is reference to an array containing(3, is an array containing (3, 4) ${$two_d[1]}[0] is the scalar value 3. note braces cannot be dropped!!! $two_d[1] is not a simple scalar! $two_d[1]->[0] is the same thing Any time an arrow separates two brackets ([] or {}), it can be dropped completely $two_d[1][0] is also the scalar value 3. Other arrows CANNOT be dropped: $foo->[1][0] is NOT equivalent to $foo[1][0] 24

25 More Complicated Using similar methods, you can create arrays of hashes, hashes of arrays, hashes of hashes, arrays of arrays of hashes, hashes of hashes of arrays, arrays of hashes of arrays,..... my %letters_in = ( lower => ['a'.. 'z'], upper => ['A'.. 'Z'] ) $letters_in{lower} is an array is an array; ${$letters_in{lower}}[1]is the scalar value 'b'. $letters_in{lower}->[1] is the scalar value 'b' $letters_in{lower}[1] is the scalar value 'b' 25

26 References and copies = (1..10); my $ref1 = \@nums; my $ref2 = ]; What's the difference? $ref1 contains a reference Changes and vice-versa. $ref2 contains a reference to an anonymous array, that happened to be populated with the contained at that moment. Changes have no effect nor vice-versa. my $ref3 = $ref1; $ref3 and $ref1 are two references to the same array. Changes also 26

27 Help available perldoc perlreftut tutorial on references perldoc perllol "lists of lists" very inaccurately named perldoc perldsc Data Structures Cookbook: building complicated structures perldoc perlref Reference reference. 27

28 Subroutines

29 Subroutines aka: user-defined functions, methods, procdures, sub-procedures, etc etc etc We ll just say Subroutines. "Functions" generally means built-in functions perldoc perlsub 29

30 The Basics sub myfunc { print "Hey, I m in a function!\n"; } # myfunc(); Because the subroutine is already declared, () are optional (ie, you can just say myfunc; ) If you call the function before declaring it, the () are required You can declare a subroutine without defining it: sub myfunc; Make sure you define it eventually. actual name of the subroutine is &myfunc ampersand not necessary to call it in fact, has (usually undesirable) side-effects 30

31 Parameters (aka Arguments, inputs, etc) You can call any subroutine with any number of parameters. The parameters get passed in via variable. my $foobar = 82; myfunc('hello', 'world', $foobar); sub myfunc{ foreach my $word (@_){ print "$word "; } print "\n"; is a normal array in every way. In this subroutine, $_[0] = 'hello', $_[1] = 'world', and $_[2] = 82 prints 'hello world 82 ' 31

32 Standard Procedure There are two "normal" ways to obtain individual parameters: sub display { my ($name, $addr) #... } shift() in a subroutine acts with no args Outside of a subroutine, acts sub display { my $name = shift; my $addr = shift; #... } Beware that the second method in the process. 32

33 Pass by value vs Pass by reference *All* parameters are passed by reference. A direct change to an element will affect the variable passed in. To pass by value instead, create a copy: my ($foo, $bar) = ('old', 'old'); change ($foo, $bar); sub change { my ($val1, $val2) $_[0] = 'new'; #changes $foo $val2 = 'new'; #does not change $bar } $foo 'new', $bar 'old' If you use the shift() method, you lose the ability to change the parameters! 33

34 & side effect #1 If you use & to call a subroutine, and don't pass any arguments, the current value will be passed automatically. &myfunc; myfunc is alias to same as saying myfunc(@_);, but faster internally In general, don't call the subroutine with &. if your subroutine checks for parameters, and you don't explicitly pass will not be empty as you expect. 34

35 Squashing array parameters If arrays or hashes are passed into a subroutine, they get squashed into one flat = (1, 2, 3); = (8, 9, 10); myfunc inside (1, 2, 3, 8, 9, 10); Same as = myfunc(@c); Maybe this is what you want. if not, you need to use references 35

36 References in Parameters To pass arrays (or hashes), and not squash them: = (1, 2, 3); = (8, 9, 10); myfunc (\@a, \@b); In contains two scalar values. Each one is a reference to an array. sub myfunc{ my ($ref1, $ref2) # } 36

37 Pass by Reference, take 2 To not change a scalar, copy the value foo($val); sub foo { $_[0] = 'new'; } Changes $val sub foo { my $copy = $_[0]; $copy = 'new'; } Does not change $val To not change an array, you must copy the array that is referenced! bar(\@vals); sub bar { 'new'; } sub bar { my $copy = $_[0]; 'new'; } $_[0] and $copy are two different references, but they both refer to the same array sub bar { 'new'; } Does is a different array 37

38 Return values All Perl blocks return last expression evaluated. sub count { #... $_[0] + $_[1]; } $total = count(4, 5); $total 9 return keyword used for explicitness, or to leave the subroutine before its lexical end sub myfunc{ if (!@_){ warn "myfunc called with no args!"; return -1; } #... } 38

39 Return issues Can return values in list or scalar context. sub toupper{ tr/a-z/a-z/ } = toupper $word1, $word2; my $upper = toupper $word1, $word2; $upper gets size Why not use tr/a-z/a-z/ 39

40 Scalar vs List Returns wantarray function Built-in function. If subroutine called in list context, wantarray returns true If subroutine called in scalar context, wantarray returns false If subroutine called in void context, wantarray returns undef. Perhaps we want to return an entire array in list context, but the first element of the array in scalar context: sub fctn{ warn "fctn() called in void context" unless defined wantarray; #... return : $params[0]; } 40

41 Subroutine References To take a reference to a subroutine, use the & and prepend a \, like you would for any other variable: my $fooref = \&foo; You can declare a reference to an anonymous subroutine Store the return value of sub in a scalar variable $subref = sub { print "Hello\n"; }; to call, de-reference the stored value: &$subref; $subref->(); #preferred works with parameters too.. &$subref($param1, $param2); $subref->($param1, $param2); Sub refs can be stored in arrays or hashes to create "dispatch tables" = (\&foo, $subref, \&baz); my $var = <STDIN>; $dipatch[$var]->(); 41

42 Scoping Recall that there are two distinct scopes of variables: Package variables and Lexical variables. Package variables available anywhere, without being declared Perl has two ways of creating 'local' variables local and my what you may think of as local (from C/C++) is actually achieved via my. local is mostly a holdover from Perl 4, which did not have lexical variables. 42

43 Where s the scope subroutines declared within a lexical s scope have access to that lexical this is one way of implementing static variables in Perl { my $num = 20; sub add_to_num { $num++ } sub print_num { print "num = $num";} } add_to_num; #increments $num print_num; #prints current val of $num print $num; #ERROR! 43

44 local local does not create new variable instead, assigns temporary value to existing package variable has dynamic scope functions called from within scope of local variable get the temporary value our ($x, $y) = (10, 20); sub fctn { print "x = $x, y = $y\n"; } { local $x = 1; my $y = 2; fctn(); } in fctn(), $main::x has a temporary value created by local The lexical $y is not accessible to fctn prints "x = 1, y = 20" 44

45 state (5.10 exclusive) A lexical variable that remembers the last value it had before it went out of scope is a "static" variable use feature ':5.10'; sub count_it { state $x = 0; say "count_it called $x times before"; $x++; } count_it(); count_it(); count_it(); say "I've called count_it $x times"; # ERROR!! The initialization is done only the first time this sub is called. After that, variable is initialized with last value it had before it went out of scope the last time. 45

46 What to know about scope my is lexically scoped Look at the actual code. Whatever block encloses my is the scope of the variable our is also lexically scoped allows you to use a package variable without fully qualifying local is dynamically scoped The scope is the enclosing block, plus any subroutines called from within that block state is lexically scoped But it remembers its previous value (only available in or higher) Almost always want my instead of local notable exception: cannot create lexical variables such as $_, $/, $", $,, etc. Only normal, alpha-numeric variables Exception: can lexicalize $_ in and higher. for built-in variables, localize them. See also: "Coping With Scoping" 46

47 Prototypes Perl s way of letting you limit how you ll allow your subroutine to be called. when declaring the subroutine, give it the type of variable you want it to take: sub f1($$) { } f1 must take two scalar values sub f2($@) { } f2 takes a scalar value, followed by a list of values recall a list can contain 0, 1, or any number of values sub f3(\@$) { } f3 takes an actual array, followed by a scalar value sub f4() { } f4 takes zero arguments of any kind sub f5(_) {...} f5 takes a single scalar, but defaults to $_ if not given and higher only 47

48 Don t use prototypes Prototypes are almost universally considered a mistake in the language. They should NEVER be used. They create a false sense of security, letting you think you don t need to check your args manually. They frequently do NOT work as expected. sub fctn($@) {... } fctn(@foo); NO ERROR! Instead, to scalar context, and lets the second argument be an empty list. sub avg($$) {... } = ($val1, $val2); avg(@args); ERROR! Won t let you pass the array containing two values 48

49 Even more pointless... The second side-effect of calling a subroutine with the & is to disable prototype checking entirely sub foo($) {... } foo(@bar, %baz); #Error &foo(@bar, %baz); #No error 49

50 Warning your users If something goes wrong in a subroutine, it's often helpful to know where the subroutine was called. sub fctn { warn "fctn called in void context" unless defined wantarray; } This will only tell the user an error occurred within the subroutine, line number will be the line of the warn() use Carp; sub fctn { carp "fctn called in void context" unless defined wantarray;} Line number reported will be line on which fctn() was called. croak : carp :: die : warn 50

51 Intro to Object Oriented Perl Packages, Modules, Classes

52 Packages Analogous to namespaces provide a virtual "location" for subroutines and global variables ALL package variables are global variables Default package is main All other packages declared with package keyword 52

53 Using Packages #!/usr/bin/env perl use warnings; #note no use strict! $foo = 'Hello'; #sets $main::foo package Bar; $foo = 'World'; #sets $Bar::foo package Vishal; print "$main::foo $Bar::foo\n"; prints "Hello World\n" 53

54 our Declares the ability to use a global variable in the current package without fully qualifying it, even with strict enabled: #!/usr/bin/env perl use strict; use warnings; package Lalli; our $var; $var = 'hello world'; package main; print "$Vishal::var\n"; 54

55 Modules A module is a package contained within an external file of the same name.pm extension file MyMod.pm: package MyMod; #no shebang!! use strict; use warnings; our ($foo, $bar, $baz); ($foo, $bar) = split / /, 'Hello World'; $baz = 42; 1; 55

56 require read the code from the given module, and executes it in the current program. Last line of module read must be a true value hence the odd 1; in MyMod.pm #!/usr/bin/env perl use strict; use warnings; require MyMod; print "$MyMod::foo $MyMod::bar\n"; print "The answer: $MyMod::baz\n"; 56

57 Module locations Directories Perl will search for modules are stored To specify your own directory, push it '/home/paul/mods/'; #run time use lib '/home/paul/mods/'; #compile time To specify a module located in a subdirectory use the :: notation: In module: package Foo::Bar::MyMod; In main script: require Foo::Bar::MyMod; looks for 'Foo/Bar/MyMod.pm' in each directory Note that a module named Foo::Bar has nothing to do with the Foo::Bar::MyMod module Foo/Bar.pm has nothing to do with Foo/Bar/MyMod.pm 57

58 require notes Remember, my is lexically scoped. Any lexicals declared in an external file will NOT be available in the main program without a { } block, lexical scope file scope If you try to access a module's variable before requiring the module, you get a run-time error To be safe, put the require in a BEGIN { } all code in BEGIN { } executed as soon as it is seen, before any remaining parts of the file are even parsed. the use keyword will do exactly this. use MyMod; BEGIN{ require MyMod; import MyMod; } import comes next class ignore for now. 58

59 Classes A class is a module that defines one or more subroutines to act as methods Class Method subroutine that expects a Class name as the first argument Object Method subroutine that expects an object of a class as the first argument Objects are simply references that "know" to which class they belong *Usually* references to hashes, but not required 59

60 Constructor Class method that creates and returns an object of the class: often named new "but only to fool C++ programmers into thinking they know what's going on." -- Camel package Student; use strict; use warnings; sub new { my $class = shift; my ($name, $UNI) my $obj = { name=>$name, UNI=>$UNI, GPA=>0 }; bless $obj, $class; return $obj; } 1; 60

61 use'ing your class #!/usr/bin/env perl use strict; use warnings; use Student; my $stu = new Student('Paul', 123); my $stu2 = Student->new('Dan', 456); print "$stu->{name}'s UNI: $stu->{uni}\n"; Perl translates the two constructor calls to: Student::new('Student', 'Paul', 123); Student::new('Student', 'Dan', 456); Even if we don't provide a form that explicitly gives the classname as the first argument, the subroutine *will* receive it anyway. Remember, new is not a keyword. It's just the name we happened to choose for the constructor. Be careful of that first call ("Indirect Object Syntax"). If there's a subroutine named 'new' in scope, *that* gets called, not your constructor! 61

62 Object Methods Note in the last example, we accessed the object's members directly. This is perfectly allowed, but rarely a good idea We will define accessors for this data by way of object methods. package Student; #... sub get_name { my $self = shift; return $self->{name}; } sub set_name { my $self = shift; my $new_name = shift; $self->{name} = $new_name; } #... in main: my $s = Student->new('Mary'); $s->set_name('jennifer'); print "Name: ", $s->get_name(), "\n"; 62

63 object methods Any method like that example: $s->set_name('jennifer'); is translated by Perl to: Student::set_name($s, 'Jennifer'); Again, even if we don't use the form that explicitly gives the object as the first parameter, the method *will* receive it as such. Do not be tempted to type the explicit form in your code. The arrow notation comes with some additional magic that we'll discuss next week. 63

64 More Methods package Student; #... sub show { my $s = shift; print "$s->{name}'s GPA is $s->{gpa}"; } sub status { my $s = shift; $s->{gpa} >= 60? 'passing':'failing'; } #remember all perl subroutines return #the last value evaluated 64

65 Destructors named DESTROY called when an object falls out of scope package Student; my $total = 0; our $DEBUG = 1; sub new { $total++; #... } sub DESTROY { print "$_[0]->{name} is gone!\n" if $DEBUG; $total --; } 65

66 What do we have here? my $class = ref($foo); if $foo is not a reference, returns false if $foo is a reference, returns what kind of reference it is 'ARRAY', 'HASH', 'SCALAR' if $foo is a blessed reference, returns $foo's class 'Student' if ($foo->isa('myclass')) { } method available to every object. Returns true if the object belongs to MyClass or to a class from which MyClass inherits. Inheritance is discussed next week 66

67 Standard Modules Perl distributions come with a significant number of pre-installed modules that you can use in your own programs. To find where the files are located on your system, examine array: print join "\n"; Gives a listing of all directories that are looked at when Perl finds a use statement. For a full list of installed standard modules: perldoc perlmodlib Many standard modules will be discussed in two weeks. 67

68 Example Built In Math::Complex Allows creation of imaginary & complex numbers Constructor named make Takes two args real & imaginary parts use Math::Complex; my $num = Math::Complex->make(3,4); print "Real: ", $num->re(), "\n"; print "Imaginary: ", $num->im(), "\n"; print "Full Number: $num\n"; Also prints: "Full Number: 3+4i" 68

69 How did it do that? Math::Complex objects can be printed like that because of overloading Overloading defining an operator for use with an object of your class. Almost all operators can be overloaded including some you wouldn't think of as operators (The Math::Complex object took advantage of overloading the "stringification" operator) 69

70 Overloading use the overload pragma, supplying a list of key/value pairs. key is a string representing the operator you want to overload value is a subroutine to call when that operator is invoked. method name, subroutine reference, anonymous subroutine use overload '+' => \&my_add, '-' => 'my_sub', '""' => sub { return $_[0]->{name} } ; perldoc overload full list of overloadable operators 70

71 Overload Handlers The subroutines you specify will be called when: Both operands are members of the class The first operand is a member of the class The second operand is a member of the class, and the first operand has no overloaded behavior They are passed three arguments. First argument is the object which called the operator. Second argument is the other operand. Third is a boolean value telling you if the operands were swapped before passing Doesn't matter for some operators (addition). Definitely matters for others (subtraction) For operators that take one argument (++, --, "", 0+, etc), second and third arguments are undef The trinary operator?: cannot be overloaded. Fortunately. 71

72 overload conversions Assuming MyMod has + overloaded to &add, - to &subtract, and "" to &string: my $obj = MyMod->new(); $x = $obj + 5; $x = $obj->add(5, ''); $x = MyMod::add($obj, 5, '') $y = $obj 5; $y = $obj->subtract(5, ''); $y = MyMod::subtract($obj, 5, '') $z = 5 - $obj; $z = $obj->subtract(5, 1); $z = MyMod::subtract($obj, 5, 1) $s = "$obj"; $s = $obj->string(undef, undef); $s = MyMod::string($obj, undef, undef); 72

73 Example package Pair; use overload '+' => \&add, '-' => \&subtract, '""' => \&string; sub create { my $class = shift; my $obj = {one=>$_[0], two=>$_[1]}; bless $obj, $class; } sub string { my $obj = shift; return "($obj->{one}, $obj->{two})"; } For example: print "My pair: $p\n"; 73

74 Overloaded addition sub add { my ($self, $other) my $class = ref $self; my ($new_one, $new_two); if (ref $other and $other->isa($class)){ $new_one = $self->{one}+$other->{one}; $new_two = $self->{two}+$other->{two}; } else { #assume $other is an integer $new_one = $self->{one}+$other; $new_two = $self->{two}+$other; } my $ret = {one=>$new_one, two=>$new_two}; return bless $ret, $class; } Called whenever a Pair object is added to something: my $p2 = $p + $p1; my $sum = 10 + $p2; 74

75 Overloaded Subtraction sub subtract { my ($self, $other, $swap) my $class = ref $self; my ($new_one, $new_two); if (ref $other and $other->isa($class)){ $new_one = $self->{one} - $other->{one}; $new_two = $self->{two} - $other->{two}; } else { $new_one = $self->{one} - $other; $new_two = $self->{two} - $other; if ($swap){ $_ *= -1 for ($new_one, $new_two); } } my $ret = {one => $new_one, two => $new_two}; return bless $ret, $class; } my $p2 = $p1 - $p; my $diff = $p2 10; my $diff2 = 10 - $p2; #Swapping! 75

76 Overloading fun It is rarely necessary to overload every needed operator. Missing operators are autogenerated by related operators: if a handler for the *= operator is not defined, Perl pretends that $obj *= $val is really $obj = $obj * $val, and uses the * handler. if a handler for 0+ (numification??) is not defined, Perl will use the "" handler to stringify the object, and convert the result to a number. if a handler for ++ is not defined, Perl will pretend that $obj++ is really $obj = $obj + 1, and use the + handler note, btw, that Perl knows how postfix and prefix are supposed to work. No need (or way) to define separate handlers for the two. 76

77 Documentation perldoc perlboot (Beginners' OO Tutorial) perldoc perltoot (Tom's OO Tutorial) perldoc perlmod perldoc perlobj perldoc overload 77

78 Stringification warning I'd like everyone to please read perldoc q quoting What's wrong with always quoting "$vars"? This is a good example of what's wrong. $obj = MyClass->new(); do_something("$obj"); if MyClass overloads '""', you'll get the stringified version of $obj. Otherwise, you'll get something like MyClass=HASH(0x43231) In either case, you will not get the object itself In general, do not use double quotes around a variable when you just need the variable. 78

79 Important Definitions package namespace module package contained in file of same name class module that defines one or more methods class method subroutine that takes class name as first argument object method subroutine that takes object as first argument object reference that is blessed into a class 79