Ethiopian multiplication in Perl6
 

Ethiopian multiplication in Perl6

on

  • 868 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.

Statistics

Views

Total Views
868
Views on SlideShare
868
Embed Views
0

Actions

Likes
0
Downloads
3
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 Ethiopian multiplication in Perl6 Presentation Transcript

  • Multiplying Ethiopians: Lambdas, Lazyness, & Perl6 Steven Lembark Workhorse Computing lembark@wrkhors.com
  • 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?
  • Rakudo Star: Perl6 in a tarball Pretty much what you are used to: Snag a tarball. perl Configure make tests install
  • 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;
  • 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;
  • 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
  • Rosetta Code Wonderful site, if you care about languages. Various algorithms, variety of languages. Perl6 versions largely coded by Larry Wall.
  • 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.
  • Maybe an example will help... 17 x 34 write down two numbers...
  • Maybe an example will help... 17 x 34 8 halve the first number to 1... 4 2 1
  • Maybe an example will help... 17 x 34 8 68 4 136 double the second number... 2 272 1 544
  • Maybe an example will help... 17 34 8 68 4 136 2 272 1 544 sum doubles with odd halves...
  • Maybe an example will help... 17 34 8 68 4 136 2 272 1 544 578 and you have the product.
  • Plan 1: Imperative programming Loop over the halved value. Doubling the other. Summing as you go.
  • 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; }
  • Perl6 More ways to do it: Parameter types. Local functions.
  • Stand-alone subs # “%%” is “divisible by”, “div” is integer division. sub halve  (Int $n is rw)    { $n div= 2 } sub double (Int $n is rw)    { $n *= 2  } sub even   (Int $n ­­> Bool) { $n %% 2  } 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; }
  • Self-contained with lexical subs sub ethiopicmult ( Int $a is copy, Int $b is copy ­­> Int ) { my &halve = * div= 2; # lexically­scoped subs my &double = * *=   2; # with placeholders. my &even = * %%   2; my  $r = 0; loop # a.k.a. for(;;) { even   $a or $r += $b; halve  $a or return $r; double $b; } }
  • Self-contained with lexical subs sub ethiopicmult ( Int $a is copy, Int $b is copy ­­> Int ) { state &halve = * div= 2; # lexically scoped “state” state &double = * *=   2; # avoids re­compiling. state &even = * %%   2; my $r = 0; loop { even   $a or $r += $b; halve  $a or return $r; double $b; } }
  • Even more than... Functional Programming: Yet Another Way to Avoid Spaghetti Code. Neither “structured programming” nor “objects”. Manage issues with state and side effects.
  • The Evil State State is hard to maintain. Coding errors: loosing, failed, multiple updates... Avoiding it reduces errors.
  • Unintended Consequences Or this:     loop     {       double $b;       even   $a or $r += $b;       halve  $a or return $r;       double $b;     }
  • “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).
  • Ideal: pure functional code Fully deterministic function calls. No surprises. Easy to test, with full validation.
  • 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.
  • Looking at it in Perl6 Replace steps with declarations. Don't say “how” say “what”.
  • Declarative definition sum a list ...
  • Declarative definition sum a list ... selecting the doubled values whose halved entry is odd ...
  • Declarative definition sum a list ... selecting the doubled values whose halved entry is odd ... from a list of pairs ...
  • 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.
  • Iterators & maps & zips, oh my! sub halve  { $^n div 2 } # $^X => self­declared sub double { $^n * 2 } # block parameter sub odd    { $^n % 2   } sub ethiopicmult ( Int $a is copy, Int $b is copy ­­> Int ) { [+] # iterate '+'. map { $^col_2 if odd $^col_1 # parameters extract in lexical order. }, zip # tuples from the lazy lists ( $a, &halve  ... 1 ; # semi­colon separates lists $b, &double ... * # indefinate lazy list ); }
  • Iterators & maps & zips, oh my! sub halve  { $^n div 2 } # $^X => self­declared sub double { $^n * 2 } # block parameter sub odd    { $^n % 2   } sub ethiopicmult ( Int $a is copy, Int $b is copy ­­> Int ) { [+] # iterate '+' on a list map ­> $half, $dbl # named parameters for map { $dbl if odd $half }, zip # tuples from the lazy lists ( $a, &halve  ... 1 ; # semi­colon separates lists $b, &double ... * # infinite lazy list ); }
  • Lexical subs do the math sub ethiopicmult( $a, $b ) { state &halve = * div= 2; state &double = * *=   2; state &odd = * %    2; [+] map ­> $half, $dbl { $dbl if odd $half }, zip ( $a, &halve  ... 0 ; $b, &double ... * ) }
  • 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 ... * ) }
  • Result Minimal, declarative syntax overall. Avoid order-of-execution errors.
  • 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 ]. The ways keep multiplying.
  • 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.
  • 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>
  • 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 ...”
  • 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.”
  • References Good overview of the vocabulary: <http://en.wikipedia.org/wiki/Functional_Programming>
  • References Academic description of Monads: <http://web.archive.org/web/20071128090030/http://homepages.inf.ed .ac.uk/wadler/papers/marktoberdorf/baastad.pdf>