CS 105 Perl: Completing the Toolbox Curtis Dunham March 4, 2013 - - PowerPoint PPT Presentation

CS 105 Perl: Completing the Toolbox

Curtis Dunham March 4, 2013

Curtis Dunham CS 105 Perl: Completing the Toolbox

Agenda

autodie with open Inspecting scalars perl -c Unary coercion Topicalization ~~ Unique list idiom Schwartzian Transform Using // for defaults and memoization Code references and closures

Curtis Dunham CS 105 Perl: Completing the Toolbox

• pen review

We’ve covered opening files for reading and writing:

• pen my $reader, ’<’, "file" or die...
• pen my $writer, ’>’, "output" or die...

The names of the file handles are not special; they are merely chosen for pedagogical value.

Curtis Dunham CS 105 Perl: Completing the Toolbox

• pen and pipes
• pen can be used to run programs that we can read from via

pipes or to run programs that we can write to via pipes. # read from another program

• pen my $reader, ’-|’, "/path/to/command" or die...

# write to another program

• pen my $writer, ’|-’, "/path/to/command" or die...

To supplement perldoc -f open, consider perldoc perlopentut for more complete coverage of the power of

• pen with good explanations.

Curtis Dunham CS 105 Perl: Completing the Toolbox

autodie

Checking the return values of every open can be very tedious and repetitive. The autodie pragma handles this responsibility automatically. use autodie;

• pen my $f, ’<’, "filename"; # this is ok...

# because autodie will... # automatically die in case of failure. autodie is similar to warnings in that it is lexical with many knobs you can adjust. See perldoc autodie.

Curtis Dunham CS 105 Perl: Completing the Toolbox

Filehandle references are handy

Since Perl is reference counted, we can depend on variable scoping to automatically close files. use IO::Handle; use autodie; { open my $file, ’>’, ’outputFile’; $file->say(’Blarg, I say.’); # ... } # $file out of scope and therefore closed! Note that to use the IO::Handle methods on the file object, you will need to load that module.

Curtis Dunham CS 105 Perl: Completing the Toolbox

Another cute open feature

Perl allows a filehandle to actually refer to a scalar (e.g. for

• utput buffering or reading from slurped data).

use IO::Handle; use autodie;

• ur $dump;

{ open my $file, ’>’, \$dump; $file->say(’Blarg into a scalar’); # ... } # use $dump at some point...

Curtis Dunham CS 105 Perl: Completing the Toolbox

What type of reference is this?

Given some arbitrary scalar, how can you tell if it is a reference? What type of a reference is it? Is it an object (a blessed reference)? Is it some other type of reference? Perl provides the ref function to help answer these questions. ref will return false if the scalar is not a reference. If the reference is blessed, ref will return the package (i.e. class)

• name. Otherwise, the type of reference will be returned (as a

string): e.g. SCALAR, ARRAY, and so on (see the documentation for further details).

Curtis Dunham CS 105 Perl: Completing the Toolbox

Is this reference blessed?

The Scalar::Util module (part of the Perl core; i.e. it “comes with” Perl) includes the function blessed. use Scalar::Util qw(blessed); $obj = bless [], "Foo"; $class = blessed $obj; # "Foo" blessed will return undef if the scalar is not a blessed reference (e.g. an unblessed reference or some other scalar value).

Curtis Dunham CS 105 Perl: Completing the Toolbox

reftype

You might want to know what type of reference is in a scalar regardless of whether it’s blessed or not. Scalar::Util has a function for this, too: reftype.

Curtis Dunham CS 105 Perl: Completing the Toolbox

perl -c

You can use perl -c to do a syntax check on your program without running it. % perl -c broken-script syntax error at broken-script line 6, near "print" broken-script had compilation errors. %

Curtis Dunham CS 105 Perl: Completing the Toolbox

Unary coercions

# numeric my $number = 0 + $whatever; # string my $string = ’’ . $whatever; # boolean my $bool = !! $whatever;

Curtis Dunham CS 105 Perl: Completing the Toolbox

Unary coercion in hash key brackets

$words{lc}++; # ’lc’. oops. $words{+lc}++; # evaluate lc (function!) # normally not necessary $words{$obj->method(’foo’) - 10} = baz();

Curtis Dunham CS 105 Perl: Completing the Toolbox

Truth Trickery

Sometimes we would like a zero value to still be interpreted as true in a boolean context (perhaps in the sense of “success”). These values evaluate to 0 in a numeric context, but aren’t one

• f the five false values.

$a = ’0e0’; $b = ’0e’; $c = ’0.0’; $d = ’0 but true’; # chatty

Curtis Dunham CS 105 Perl: Completing the Toolbox

Using given for topicalization

given implicitly sets $_ to its argument. given ($important) { s/_+//g; say; } This code won’t modify $important, but it allows us to do something with it with both brevity and safety.

Curtis Dunham CS 105 Perl: Completing the Toolbox

given-less when

You can use the magic of when (~~ and more) in a for loop, too! my $count; my $v = 0; for (@a) { when($v) { ++$v } say "Nope, not that one."; } say "Made it to $v"; This only works when not specifying an iteration variable (i.e. using default $_). The when block has an implicit next at the end.

Curtis Dunham CS 105 Perl: Completing the Toolbox

~~ is the operator behind the curtain

Many of you have already used ~~ without realizing it! In a given / when construct, the left-hand operand is provided by given and the right-hand operand is provided by the when.

Curtis Dunham CS 105 Perl: Completing the Toolbox

Explicit use of ~~

~~ is the smart match operator (new in Perl 5.10). It is a kitchen-sink style polymorphic operator that determines whether the two operands “match” in some dwimmy way. Here are some of its default behaviors: $a ~~ undef # true if $a is undef $a ~~ /$b/ # same as =~ @a ~~ /$b/ # grep /$b/, @a %a ~~ /$b/ # grep /$b/, keys %a $a ~~ @b # grep { $a ~~ $_ } @b %a ~~ %b # hash keys identical This is just a small subset of all the behaviors ~~ has. The perlsyn page lists all of its behaviors.

Curtis Dunham CS 105 Perl: Completing the Toolbox

Getting unique elements in a list

my %uniq; undef @uniq{ @items }; my @uniques = keys %uniq; # makes a nice little subroutine sub uniq { my %u; undef @u{@_}; return keys %u; }

Curtis Dunham CS 105 Perl: Completing the Toolbox

Schwartzian Transform

The Schwartzian Transform is a Perl sorting idiom devised by Randal Schwartz. Sometimes we want to sort a list of things by some arbitrary function of the elements. This can be troublesome if the function is very expensive–say, computationally, or if involves I/O in some way. Randal’s solution is to create a list of anonymous arrays, where each original list element is paired with the value that will be used for sorting. # first step of Schwartzian Transform @x = map { [ $_, -s $_ ] } @files;

Curtis Dunham CS 105 Perl: Completing the Toolbox

Schwartzian Transform Continued

@x = map { [ $_, -s $_ ] } @files; So now we have an array of 2-tuples (file name and file size, stored in anonymous arrays) that we want to sort using the second element of the tuple. @y = sort { $a->[1] <=> $b->[1] } @x; Now our data is sorted, but our data is stuck in that messy

• thing. Let’s rescue it.

@z = map { $_->[0] } @y; # @z is our sorted list of files!

Curtis Dunham CS 105 Perl: Completing the Toolbox

Schwartzian Transform: All Together Now

We just stick the code samples together in reverse order, eliminating the temporary arrays. @sorted_files = map { $_->[0] } sort { $a->[1] <=> $b->[1] } map { [ $_, -s $_ ] } @files; Once you get past the punctuation (I understand this is still a stumbling block for some of you), it’s actually quite simple. We keep the sorting data with the data to be sorted so that we only compute it once. Then we remove that extra data when we no longer need it.

Curtis Dunham CS 105 Perl: Completing the Toolbox

|| revisited

The or operator (||, or or for a very low precedence version of the same) is a good way to inject a default. sub new { my $class = shift; my %params = @_; bless { _foo => $params{foo} || 10, _bar => $params{bar} || ’bar’, _baz => $params{baz} || [ qw(a b c) ], }, $class; }

Curtis Dunham CS 105 Perl: Completing the Toolbox

// is better here

The // (“defined-or”) operator works like || except that it uses a definedness test rather than truth. use v5.10; sub new { my $class = shift; my %params = @_; bless { _foo => $params{foo} // 10, _bar => $params{bar} // ’bar’, _baz => $params{baz} // [ qw(a b c) ], }, $class; }

Curtis Dunham CS 105 Perl: Completing the Toolbox

Another use for || and //

Sometimes we might use a hash as a “cache” for some computation, but we want to load it lazily (on demand). This idiom is common in this case: my $a = $foo{$val} //= foo($val); Assignment is right-associative, so the statement evaluates like this: my $a = ($foo{$val} //= foo($val)); If a value exists in the hash, we can just use it; otherwise we can use the function foo to compute the value, store it in the hash, and also put it in $a.

Curtis Dunham CS 105 Perl: Completing the Toolbox

Subroutine/Function Review

# What you already know # (named; not anonymous) sub named_func { # ... } named_func(); # call

Curtis Dunham CS 105 Perl: Completing the Toolbox

Anonymous subroutines/functions

# Anonymous my $anon = sub { # ... }; $anon->(); # call Notice the major differences: no function name after sub, assignment to a scalar, semicolon to end the assignment, and the ->() dereferencing-call syntax.

Curtis Dunham CS 105 Perl: Completing the Toolbox

Stack homework revisited

• ur @stack;

%ops = ( ’+’ => sub { push @stack, (pop(@stack) + pop(@stack)); }, ’-’ => ... ); while(<>) { chomp; if ($ops{$_}) { $ops{$_}->(); } else # ... }

Curtis Dunham CS 105 Perl: Completing the Toolbox

Another type of reference

$ perl print ref(sub{})."\n"; ^D CODE $ As you can see, ref will return the string CODE when presented with an anonymous function (other interchangable terminology: anonymous sub, coderef).

Curtis Dunham CS 105 Perl: Completing the Toolbox

All subs are closures (even anonymous ones)

In a code example last time we had code like this: { my $privateVar = 11; sub myFunc { my $a = $_[0] + $privateVar; # ... $privateVar = ... } sub myOtherFunc { # can also see $privateVar } } The $privateVar variable goes out of scope, but since myFunc refers to it, it stays around like a static variable within that subroutine.

Curtis Dunham CS 105 Perl: Completing the Toolbox

Generating counter functions

sub makeCounter { my $startValue = shift; return sub { $startValue++ }; } my $CounterA = makeCounter(1); my $CounterB = makeCounter(500); $CounterA->(); # returns 1 $CounterA->(); # returns 2 $CounterB->(); # returns 500 $CounterB->(); # returns 501 $CounterB->(); # returns 502 # etc.. We can provide each closure with its own private counter!

Curtis Dunham CS 105 Perl: Completing the Toolbox