Ethiopian multiplication in Perl6
 

Like this? Share it with your network

Share

Ethiopian multiplication in Perl6

on

  • 974 views

Perl6 introduces a variety of tools for functional programming and generating readable code in all cases. Among them parameter declarations and lazy lists. This talk looks at how to get Perl6, where ...

Perl6 introduces a variety of tools for functional programming and generating readable code in all cases. Among them parameter declarations and lazy lists. This talk looks at how to get Perl6, where to find examples on RakudoCode, and how to use the tools for converting an algorithm from imperative to functional code using Perl6, and parallel dispatch with the ">>" operator.

Statistics

Views

Total Views
974
Views on SlideShare
974
Embed Views
0

Actions

Likes
1
Downloads
4
Comments
0

0 Embeds 0

No embeds

Accessibility

Categories

Upload Details

Uploaded via as Adobe PDF

Usage Rights

CC Attribution-ShareAlike LicenseCC Attribution-ShareAlike License

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

Ethiopian multiplication in Perl6 Presentation Transcript

  • 1. Hyper-Multiplying Ethiopians: Lambdas, Lazyness, & Perl6 Steven Lembark Workhorse Computing lembark@wrkhors.com
  • 2. Welcome to Perl6 Rakudo-Star distro. Rosetta Code. Ethiopic Multiplication: What it is. More than one way to do it. Starting with imperative approach. Perl6 for functional coding?
  • 3. Rakudo Star: Perl6 in a tarball Pretty much what you are used to: Snag a tarball. perl Configure make tests install
  • 4. Acquiring Rakudo-Star Call it “Rakudo” from now on. http://rakudo.org/ Bi-monthly updates are in ./downloads/star wget .../rakudo-star-2014.01.tar.gz; gzip -dc < *.tar.gz | tar xf -; cd rakudo-star-2014.01; less README;
  • 5. Acquiring Rakudo-Star Call it “Rakudo” from now on. http://rakudo.org/ Bi-monthly updates are in ./downloads/star wget .../rakudo-star-2013.10.tar.gz; gzip -dc < *.tar.gz | tar xf -; cd rakudo-star-2013.10; perl Configure.pl –build-parrot; gmake; gmake rakudo-test; gmake install;
  • 6. Information on Perl6 rakudo.org has links to everything else Perl6-ish. Rakudo's own doc's page is at: <http://rakudo.org/documentation> Also the Perl Maven: Gabor Szabo <http://perl6maven.com/> For example: ./parsing-command-line-arguments-perl6
  • 7. Rosetta Code Wonderful site, if you care about languages. Various algorithms, variety of languages. Perl6 versions largely coded by Larry Wall.
  • 8. Ethiopian Multiplication http://rosettacode.org/wiki/Ethiopian_Multiplication Developed in the time of roman numerals: MCMXIV * XXXIIV = ?? Using integer math: Halve the first number to 1, doubling the second one. Sum doubled numbers if the halved ones are odd.
  • 9. Maybe an example will help... 17 x 34 write down two numbers...
  • 10. Maybe an example will help... 17 x 34 8 halve the first number to 1 4 using integer math... 2 1
  • 11. Maybe an example will help... 17 x 34 8 68 4 136 double the second number... 2 272 1 544
  • 12. Maybe an example will help... 17 34 8 68 4 136 2 272 1 544 sum the doubles with odd halves...
  • 13. Maybe an example will help... 17 34 8 68 4 136 2 272 1 544 578 and you have the product.
  • 14. Plan 1: Imperative programming Loop over the halved value. Doubling the other. Summing as you go.
  • 15. What it looks like in Perl5 sub halve { int((shift) / 2) } sub double { (shift) * 2 } sub iseven { ((shift) & 1) == 0 } sub ethiopicmult { my ($plier, $plicand) = @_; my $r = 0; while ($plier >= 1) { $r += $plicand unless iseven $plier; $plier = halve $plier; $plicand = double $plicand; } return $r; }
  • 16. Perl6 More ways to do it: Parameter types. Local functions.
  • 17. Stand-alone subs sub halve (Int $n is rw) { $n div= 2 } # integer divide sub double (Int $n is rw) { $n *= 2 } sub even (Int $n ­­> Bool) { $n %% 2 } # is­divisible sub ethiopicmult ( Int $a is copy, Int $b is copy ­­> Int ) { my $r = 0; while $a { even $a or $r += $b; halve $a; double $b; } return $r; }
  • 18. Embedded subs sub ethiopicmult ( Int $a is copy, Int $b is copy ­­> Int ) { sub halve (Int $n is rw) { $n div= 2 }; # subs are sub double (Int $n is rw) { $n *= 2 }; # lexically sub even (Int $n ­­> Bool) { $n %% 2 }; # scoped my $r = 0; while $a { even $a or $r += $b; halve $a; double $b; } return $r; }
  • 19. Self-contained with lexical subs sub ethiopicmult ( Int $a is copy, Int $b is copy ­­> Int ) { my &halve = * div= 2; # placeholders save my &double = * *= 2; # syntax. my &even = * %% 2; my $r = 0; loop # a.k.a. for(;;) { even $a or $r += $b; halve $a or return $r; double $b; } }
  • 20. Self-contained with lexical subs sub ethiopicmult ( Int $a is copy, Int $b is copy ­­> Int ) { state &halve = * div= 2; # “state” avoids state &double = * *= 2; # re­compiling. state &even = * %% 2; my $r = 0; loop { even $a or $r += $b; halve $a or return $r; double $b; } }
  • 21. Even more than... Functional Programming: Yet Another Way to Avoid Spaghetti Code. Neither “structured programming” nor “objects”. Manage issues with state and side effects.
  • 22. The Evil State State is hard to maintain. Coding errors: loosing, failed, multiple updates... Avoiding it reduces errors.
  • 23. Unintended Consequences One bad paste: loop { double $b; even $a or $r += $b; halve $a or return $r; double $b; }
  • 24. “Functional” programming e.g., Haskell, Scheme, Scala, Clojure Declarative: describe the answer more so than steps. (e.g., order of execution in Haskell is derived).
  • 25. Ideal: pure functional code Fully deterministic function calls. No surprises. Easy to test, with full validation.
  • 26. Catch: it doesn't work Examples? Current time. Database query. Random number. User input. Result: Be realistic in applying the theory. Isolate state, don't eliminate it.
  • 27. Looking at it in Perl6 Replace steps with declarations. Don't say “how” say “what”.
  • 28. Declarative definition sum a list ...
  • 29. Declarative definition sum a list ... selecting the doubled values whose halved entry is odd ...
  • 30. Declarative definition sum a list ... selecting the doubled values whose halved entry is odd ... from a list of pairs ...
  • 31. Declarative definition sum a list ... selecting the doubled values whose halved entry is odd ... from a list of pairs ... halving the first value to one, doubling the second one each time.
  • 32. Iterators & maps & zips, oh my! sub ethiopicmult ( Int $a is copy, Int $b is copy ­­> Int ) { state &halve = * div= 2; state &double = * *= 2; state &odd = * % 2; [+] # iterate '+'. map # map pulls two values each time. { $^col_2 if odd $^col_1 # parameters extract in lexical order. }, zip # new list from the list arguments ( $a, &halve ... 1 ; # semi­colon separates lists $b, &double ... * # indefinate lazy list ); }
  • 33. Inline list generators replace subs # what you see is all you get: sub ethiopicmult ( Int $a is copy, Int $b is copy ­­> Int ) { [+] map ­> $half, $dbl { $dbl if $half % 2 }, zip ( $a, * div 2 ... 0 ; # implicit subs $b, * * 2 ... * ) }
  • 34. Result Minimal, declarative syntax. Avoid order-of-execution errors. Hopefully more descriptive, easier to maintain.
  • 35. Result Minimal, declarative syntax. Avoid order-of-execution errors. Hopefully more descriptive, easier to maintain. But wait! There's More!
  • 36. What you are used to Processing a list with map: @result = map { $_->$method( @argz ) } @inputs; - Single-threaded. - Fixed order of input. - Fixed order of processing.
  • 37. Perl6 adds “hyperoperators” The “»” or “>>” executes its arguments in parallel: @result = @objects».&function( @args ); @objects might be blessed or class, literal or variable. @result is stored in the same order as @objects. The order of execution is indeterminate.
  • 38. Zipping pairs, not flat lists. “zip” generates a flat list, we need single vlaues. Infix “Z=>” normally used for hashes: my %hash = ( ( $a, * div 2 … 0 ) Z=> ( $b, * * 2 … * ) ); Result is a list of key:value “pairs”: ( ( 17, 34 ) ; ( ( 8, 68 ) ; … )
  • 39. Processing pairs Pair object has a “key” and “value”: sub odd_values( $pair ) { $pair.key % 2 ?? $pair.value !! () } Which leaves us with the values that have to be summed.
  • 40. Generating the list of odd values The result of calling “odd_values” is summed just as before: [+] ( ( $a, * div 2 … 0 ) Z=> ( $b, * * 2 … * ) ) ».odd_values Selection of odd values is parallel. Generation of pairs and sum are single-threaded.
  • 41. Reading on the ceiling Catch: map-ish code reads “upside down”. Ever wish you could read it going down the page?
  • 42. Standing on your own two feet Wish no more: the “Feed operator” pushes the list downhill: ( ( $a, * div 2 … 0 ) Z=> ( $b, * * 2 … * ) ) ».odd_values ==> [+] The feed operator shows the direction of data flow. Feeds odds_values parallel results to block-iterator on '+'.
  • 43. The result sub ethiopic_mult( $a, $b ) { sub odd_values( $pair ) { $pair.key % 2 ?? $pair.value :: () } (( $a, * div 2 ... 0 ) Z=> ( $b, * * 2 ... ) )) >>.&odd_values ==> [+] }
  • 44. Hyper-whybotherators? “$a % 2” is low overhead. Say you were comparing DNA or proteins... … running a complex financial calculation... … playing conway's game of life? Wouldn't it be nice to queue the operations without loops, forks, breaks, joins, co‑routines, or queues?
  • 45. What's this got to do with FP? Hyperoperators lack repeatable sequence. No way to know order of side effects or state updates. Manipulating state or side effects don't work. Simple fix: Use FP [-ish] functions for hyperoperators.
  • 46. New things in Perl6 %% is “Divisible By” (vs. % for “modulo”). my &subname = ... for lexically defined subs. * for parameters. $^foo for block parameters. Integer division with 'div'. Parameterized lists with $start, OP, $end. List operators with [ OP ]. Hyperopertors & friends.
  • 47. References Monads in Perl5: <http://web.archive.org/web/20080515195640/http://sleepingsquirrel.o rg/monads/monads.html> Introduces the basic ideas of functional programming with monads using Perl5 examples.
  • 48. References Readable descriptions of “Monad”: <https://stackoverflow.com/questions/44965/what-is-a-monad> <https://stackoverflow.com/questions/2704652/monad-in-plain-english- for-the-oop-programmer-with-no-fp-background>
  • 49. References What databases mean to Functional Programming: <https://stackoverflow.com/questions/8406261/most-common-pattern-for- using-a-database-in-a-functional-language-given-desire> “The most common pattern for dealing with side-effects and impurity in functional languages is: - be pragmatic, not a purist ...”
  • 50. References Realistic view of FP: <https://stackoverflow.com/questions/330371/are-databases-and-functional- programming-at-odds> “Functional languages do not have the goal to remain stateless, they have the goal to make management of state explicit.”
  • 51. References Good overview of the vocabulary: <http://en.wikipedia.org/wiki/Functional_Programming>
  • 52. References Academic description of Monads: <http://web.archive.org/web/20071128090030/http://homepages.inf.ed .ac.uk/wadler/papers/marktoberdorf/baastad.pdf>