Functional Pe(a)rls - the Purely Functional Datastructures edition

Functional Pe(a)rls osfameron @ IPW2011, Turin the “purely functional data structures” editionhttp://www.fickr.com/photos/jef_saf/3493852795/

previously on Functional Pe(a)rls... (IPW, LPW, YAPC::EU, nwe.pm) currying operator references: op(+) Acme::Monads Devel::Declare

C I A O vs.C I A O

0 1 2 3 C I A O

0 1 2 3 C I A O0th element

0 1 2 3 M I A O0th element

0 1 2 3 M I A O 0th elementno kittens were harmed during the making of this presentation

0 1 2 3 M I A O 2nd element

0 1 2 3 M I A O 4th element

0 1 2 3 M I A Omax: 3

0 1 2 3 4 M I A O Wmax: 4 4th element

max: 30 1 2 3 100,000M I A O …

0 1 2 3 M I A Omax: 3

0 1 2 3 4 M I A O Wmax: 40 1 2 3 4 5 M I A O W !max: 5

Arrays C I A O vs.C I A O

Perl @arrays C I A O “dynamic array” vs.C I A O

C I A O

C I A OHead

C I A O Tail

C I A O

C I A O0th

C I A O nth - 1

C I A Onth[2]? nth[1]?

C I A Onth[2]? nth[0]!

C I A O ?

● C I tail “ciao” → “iao” A O ?

● C I tail “ciao” → “iao” A O ?● tail “iao” → “ao”● tail “ao” → “o”● tail “o” → ?

● C I tail “ciao” → “iao” A O ?● tail “iao” → “ao”● tail “ao” → “o”● tail “o” → “” (the empty string)

C I A O

List =Head Tail (another List) or...

Here comes the science^wPerl!

Moose(X::Declare)use MooseX::Declare;BEGIN { role_type List }role List { requires head; requires tail;}

List::Linkclass List::Link with List { has head => ( is => ro, isa => Any ); has tail => ( is => ro, isa => List ),}

List::Emptyclass List::Empty with List { method head { die "Cant take head of empty list!" } method tail { die "Cant take tail of empty list!" }}

So we can write:my $list = List::Link->new( head => c, tail => List::Link->new( head => i, tail => List::Link->new(...

Sugar!my $list = List->fromArray( qw/ c i a o /);

Multimethodsuse MooseX::MultiMethods;multi method fromArray ($class:) { return List::Empty->new;}

Multimethodsmulti method fromArray ($class: $head, @tail) { return List::Link->new( head => $head, tail => $class->fromArray(@tail), );}

Eeek! Recursion!my $list = List::fromArray(1..1000000);

Eeek! Recursion!my $list = List::fromArray(1..1000000);Deep recursion on subroutine"List::fromArray" at foo.pl line 20

Eeek! Recursion!multi method fromArray ($class: $head, @tail) { return List::Link->new( head => $head, tail => $class->fromArray(@tail), );}

Eeek! Recursion!fromArray

Eeek! Recursion!fromArray List::Link->new (..., fromArray)

Eeek! Recursion!fromArray List::Link->new (..., fromArray) List::Link->new (..., fromArray)

Eeek! Recursion!fromArray List::Link->new (..., fromArray) List::Link->new (..., fromArray) List::Link->new (..., fromArray)

Eeek! Recursion!fromArray List::Link->new (..., fromArray) List::Link->new (..., fromArray) List::Link->new (..., fromArray) List::Link->new (..., fromArray)

Eeek! Recursion!fromArray List::Link->new (..., fromArray) List::Link->new (..., fromArray) List::Link->new (..., fromArray) List::Link->new (..., fromArray) = $list

Eeek! Recursion!fromArray List::Link->new (..., fromArray) List::Link->new (..., fromArray) List::Link->new (..., fromArray) = $list

Eeek! Recursion!fromArray List::Link->new (..., fromArray) List::Link->new (..., fromArray) = $list

Eeek! Recursion!fromArray List::Link->new (..., fromArray) = $list

Eeek! Recursion!fromArray = $list

Eeek! Recursion!no warnings recursion;$DB::deep = 100_000_000;

Eeek! Recursion!no warnings recursion;$DB::deep = 100_000_000;Papering over the cracks

Tail Call EliminationSub::Call::TailSub::Call::Recurby nothingmuch

Tail call eliminationfromArray

Tail call eliminationList::Link->new(..., fromArray)

Tail call elimination List::Link->new (..., fromArray)

Tail call elimination List::Link->new (..., fromArray) = $list

Tail Call Eliminationuse Sub::Import Sub::Call::Tail tail => { -as => tail_call };multi method fromArray ($self: $head, @tail){ tail_call List::Link->new( head => $head, tail => $self->fromArray(@tail), );}

Indexing into Listmulti method nth (List::Empty $self: Int $pos){ die "Cant index into an Empty list";}

Indexing into List multi method nth (Int $pos where { $_ == 0 }){ return $self->head;}

Indexing into Listmulti method nth (Int $pos where { $_ > 0 }){ tail_call $self->tail->nth( $pos - 1 );}

C I A OM

C I A OM W

C I A OM W Mutation leads to bugs (and misspellings!)

C I A OM I A O W

C I A OC I B

C I A OC I B Copy everything upstream of a change Downstream of changes can be shared

C I A OC I B O Doubly linked lists have no downstream!

pure-fp-book● https://github.com/osfameron/pure-fp-book● Purely Functional Data Structures for the... ● Impure ● Perl Programmer ● Working Programmer ● Mutable, Rank-Scented Many

Functional Pe(a)rls - the Purely Functional Datastructures edition

by osfameron on Sep 09, 2011

Accessibility

Categories

Tags

Upload Details

Usage Rights

Statistics

Functional Pe(a)rls - the Purely Functional Datastructures edition — Presentation Transcript