Good Evils In Perl

Good Evils in Perl
Kang-min Liu <gugod@gugod.org>

$speaker.meta
• • http://handlino.com/
Kang-min Liu
gugod

• http://gugod.org

• http://twitter.com/gugod

• gugod@gugod.org

TIMTOWTDI
There is more then one way to do it

pragma = one small
english word.

Module = title-cased

just an convention.

Module::Acme
pragma

warnings
gives you good warning messages

Can anyone tell me if
there’s any problem in
this small program ?

foo.pl

#!/usr/bin/perl
print $foo;
print quot;Helloquot;;

Can any one see a
problem in this program ?

#!/usr/bin/perl
use warnings;

print $name;
print quot;Helloquot;;

use strict;
it breaks your program

given - when - default
given ($foo) {
when (1) { say quot;$foo == 1quot; }
when ([2,3]) {
say quot;$foo == 2 || $foo == 3quot;
}
when (/^a[bc]d$/) {
say quot;$foo eq 'abd' || $foo eq 'acd'quot;
}
when ($_ > 100) { say quot;$foo > 100quot; }
default { say quot;None of the abovequot; }
}

state variables

sub counter {
state $counts = 0;
$counts += 1;
}

Perl6::*
Perl6 functions implemented in Perl5

Perl6::Junctions
any, all

Q: How to test if an
array contains a speciﬁc
value ?

$found = 0;
foreach $a (@ar) {
if ($a == 42) {
$found = 1;
last;
}
}
if ($fount) {
...
}

if ( grep { $_ == 42 } @ar ) {
...
}

if ( grep /^42$/ @ar ) {
...
}

use Perl6::Junction qw/ all any none one /;

if ( any(@ar) == 42 ) {
...
}

if (none(@ar) > 42) {
...
}

any(values %params) == undef

html form validation

any(@birthday) < str2time(quot;1980/01/01quot;)

Can anyone see what it
does now ?

Can anyone write a
nested loop version in 10
seconds ?

if ( any(@a) == any(@b) ) {
...
}

• Perl6::Junction (any, all)
• Perl6::Perl
• Perl6::Builtins (system, caller)
• Perl6::Form
• Perl6::Gather

my $range = 10−>to(1);
# => [ 10, 9, 8, 7, 6, 5, 4, 3, 2, 1 ]

quot;Hello, world!quot;−>uc();
# => quot;HELLO, WORLD!quot;

TryCatch
ﬁrst class try catch semantics

sub foo {
eval {
# some code that might die
return quot;return value from fooquot;;
}
if ($@) {
...
}
}

sub foo {
try {
# some code that might die
return quot;return value from fooquot;;
}
catch (Some::Error $e where { $_->code > 100 } ) {
...
}
}

Sub::Alias
easier function alias

sub name { quot;gugodquot; }

alias get_name => 'name';
alias getName => 'name';

package MyClass;

sub myMethod {
my $self = shift;
...
}

package MyClass;
use self;
sub myMethod {
...
}

Perl (5) is not like other Object Oriented Languages... does
NOT have an OO built-in

That's why you should learn perl if you want to learn OO!

You can learn how to make an object system, not just how
to use it.

Dan Kogai

package Point;
use Moose;

has 'x' => (is => 'rw', isa => 'Int');
has 'y' => (is => 'rw', isa => 'Int');

sub clear {
my $self = shift;
$self->x(0);
$self->y(0);
}

class BankAccunt {
has 'balance' => (
isa => 'Num', is => 'rw', default => 0
);

method deposit (Num $amount) {
$self->balance( $self−>balance + $amount );
}

method withdraw (Num $amount) {
my $current_balance = $self−>balance();
( $current_balance >= $amount )
|| confess quot;Account overdrawnquot;;
$self->balance( $current_balance − $amount );
}
}

package Cat;
use Rubyish;

attr_accessor quot;namequot;, quot;colorquot;;

def sound { quot;meow, meowquot; }

def speak {
print quot;A cat goes quot; . $self−>sound . quot;nquot;;
}

sub doMyWork {
my ($arr1, $arr2) = @_;
my @arr1 = @$arr1;
my @arr2 = @$arr2;
...
}

doMyWork(@foo, @bar);

sub doMyWork(@@) {
my ($arr1, $arr2) = @_;
my @arr1 = @$arr1;
my @arr2 = @$arr2;
...
}

doMyWork(@foo, @bar);

if (many { $_ > 50 } @arr) {
....
}

sub many(&@) {
my ($test_sub, @arr) = @_;
...
}

sub AUTOLOAD {
my $program = $AUTOLOAD;
$program =~ s/.*:://;
system($program, @_);
}
date();
who('am', 'i');
ls('−l');

package BANG;
use Filter::Simple;

FILTER {
s/BANGs+BANG!!!/die 'BANG' if $BANG/g;
};

1;

use Acme::Morse;
.--.-..--..---.-.--..--.-..--..---.-.--.
.-.-........---..-..---.-..-.--..---.--.
..-.---......-...-...-..--..-.-.-.--.-..
----..-.-.--.-..--..-.-...---.-..---.--.
.-...-..--.---...-.-....

DB
inheritable built-in debugger

# from self.pm
sub _args {
my $level = 2;
my @c = ();
package DB;
@c = caller($level++)
while !defined($c[3]) || $c[3] eq '(eval)';
return @DB::args;
}

PadWalker
runtime stack traveler

sub inc_x {
my $h = peek_my(1);
${ $h->{'$x'} }++;
}

use Binding;
sub inc_x {
my $b = Binding->of_caller;
$b->eval('$x + 1');
}

sub two {
my $x = 1;
inc_x;
}

Devel::Declare
compile-time magician

How it works
• you deﬁne “declarator” keywords
• it let compiler stop at the keywords
• your code parse the current line in your
way, maybe re-write it
• you re-place current line with the new
version
• it resumes the compiler on the current line

def foo($arg1, $arg2) {
....
}

def foo($arg1, $arg2) {
....
}

sub foo {
my ($arg1, $arg2) = @_;
}

B::Hooks::*
more compile time fun

The most extendable
programming language

• variables
• functions, methods
• operator overloading

• operators
• grammars / rules
• sub-language

Perl5 world

• B::Generate
• Source Filter
• Devel::Declare

Perl is like the Force. It
has a light side, a dark
side, and it holds the
universe together.

Larry Wall

Good Evils In Perl

Related slideshows

More Related Content

Good Evils In Perl