1. Functional Programming
Perl
Christopher Mckay
error@errorific.com

2. What Am I

3. What's this talk all about?

4. History

5. How

6. Why not?

7. But I don't use/appreciate/like perl?

8. Functional Programming is Easy

9. So easy sysadmins do it

10. In the beginning...

12. Wrote Pearl Perl

13. People wanted a sort function
Larry was generous

14. sort
F(a, a), [a] --------> [a]

15. @sorted_list
= sort {$_[0] <=> $_[1]} @list

16. @sorted_list
= sort {$a <=> $b } @list

17. @sorted_list
= sort {$a <=> $b} @list

18. sort String sorting
sort {$a cmp $b} Also string sorting
sort {$a <=> $b} Sort numerically
sort &comparator Sort by function
named comparator

19. sort {
@a = split ///, $a;
@b = split ///, $b;
($a[2] <=> $b[2])
|| ($a[1] <=> $b[1])
|| ($a[0] <=> $b[0])
|| 0;
} @list_of_dmy_dates

20. 1988 - Perl 2.0
1989 - Perl 3.0
1991 - Perl 4.0

21. grep
F(a, a), [a] --------> [a]

22. map
F(a), [a] --------> [a]

23. 1994 – Perl 5.0

24. memoize
F(a) → b --------------> F(a) → b

25. List::Util
reduce
F(a, b) → b, [a] --------------> b

26. List::MoreUtils
any, all, none, notall, true, false, firstidx,
first_index, lastidx, part, mesh,
last_index, insert_after, zip, uniq, apply,
indexes, after, after_incl, before,
before_incl, firstval, first_value, lastval,
last_value, pairwise, distinct, minmax

28. So Perl evolved a functional theme

29. So how do I make functional stuff in
perl instead of just using it?

30. Lexical scoping

31. First class functions

32. That's about it.
Your language does that too right?

33. So lets write a function that rolls a
die

34. my $dx = sub {
my ($sides) = @_;
return (rand() * $sides) + 1;
}
my $roll = $dx->(6);

35. I don't like rolling 1's though so...

36. my $cheat = sub {
my ($roll) = @_;
if ($roll < 2) {
return 2;
} else {
return $roll;
}
}

37. I don't want to get caught turning the
die over though so ...

38. my $inconspicuous_dx = sub {
my ($sides) = @_;
return $cheat->($dx->($sides));
}

39. my $compose = sub {
my ($fa, $fb) = @_;
return sub {
return $fa->($fb->(@_));
}
}

40. my $inconspicuous_dx =
$compose->($cheat, $dx);
my $better_roll =
$inconspicuous_dx->(6);

41. Monads in Perl
Masahiro Honma (hiratara)
YAPC::Asia 2011
Slides are in english
Data::Monad

42. All I ever need is d6!

43. my $d6 = sub {
return $inconspicuous_dx->(6);
};
my $roll_a_6 = $d6->();

44. Too lazy to roll 20d6

45. my $dice_tower_maker = sub {
my ($die) = @_;
return sub {
my ($rolls) = @_;
return map {
$die->()
} (1 .. $rolls);
}
}

46. my $dice_tower =
$dice_tower_generator->($d6);
say join(', ', $dice_tower->(20));

47. use List::Util;
say sum $dice_tower->(20);

48. use List::Util;
say reduce {$a + $b}
$dice_tower->(20);

49. So why not use this stuff for
everything?

50. The compilers not out to help you

51. Declaring functions gets obtuse
after awhile

52. Purity isn't an option, everything
changes

53. The community loves objects

54. If it was simple in a functional
language it probably takes some
hacking to make it work in perl

55. And the language isn't extensible,
yet

56. Good things are to come

57. Perl 6

58. Static typing
Better syntax
Blocks and closures
List comprehension
Automatic parallelisation
Lots more

59. Thanks
Questions?