Beefy Boxes and Bandwidth Generously Provided by pair Networks
Your skill will accomplish
what the force of many cannot
 
PerlMonks  

Re^7: Next Language to Learn

by rovf (Priest)
on Mar 31, 2010 at 12:34 UTC ( #832027=note: print w/ replies, xml ) Need Help??


in reply to Re^6: Next Language to Learn
in thread Next Language to Learn

> For instance it would be interesting to see, how easy/clumsy it is to retrofit lazy evaluation into Perl. E.g.you can tie an iterator to a variable. ... gimme an example and I'll see what's possible.
Good point.

For example, we have a function which generates the list of all even numbers, i.e.

sub list_all_even { _list_all_even_from(0) } sub _list_all_even_from { my $from=shift; ($from, _list_all_even_from($from+2)) }
and a function which returns the first n elements from a list:
sub head { my ($n,@list)=@_; $n ? ($list[0],head($n-1,butfirst(@list))) : () } sub butfirst { shift; @_ }

Calling head(5,list_all_even) should return the first even numbers, but in the implementation I gave, list_all_even would, of course, loop forever. Under lazy evaluation, list_all_even would only produces those values which are actually needed, so maybe your general idea of using an operator would lead in the right direction...
-- 
Ronald Fischer <ynnor@mm.st>


Comment on Re^7: Next Language to Learn
Select or Download Code
Re^8: Next Language to Learn (Lazy Perl)
by LanX (Canon) on Apr 01, 2010 at 09:57 UTC
    Is this supposed to be Haskell code or Haskell semantics?

    For me it looks more like LISP phrased in Perl..

    Did you mean:

    sub all_even_from{ my $even=shift; sub { $even+=2; } } $iter=all_even_from(4); print $iter->() for (1..5);
    ?

    > so maybe your general idea of using an operator would lead in the right direction...

    I didn't talk about operators but about tie.

    Using Tie::Array you could try to tie the iterator to an array @even such that you can subsequently write something like this, _with_ lazy evaluation.

    for (1 ..5) { print shift @even; }

    again, show me what you like about Haskell - eg list comprehensions (???) - and I will see whats feasible.

    Cheers Rolf

      Is this supposed to be Haskell code or Haskell semantics?
      Perl-Code to show the general idea of how to apply lazy evaluation, not restricted to Haskell (which is just one of the languages having lazy evaluation builtin).
      Using Tie::Array you could try to tie the iterator to an array @even such that you can subsequently write something like this, _with_ lazy evaluation.
      Good point!
      show me what you like about Haskell - eg list comprehensions (???) - and I will see whats feasible.
      I'm not an advocate for a particular language (Haskell was just given as an example, because several implementations are available), but I like the idea in FP that you don't have side effects. This is nice for the programmer, but can be hairy for the implementation. List comprehension helps if you transform arrays, but I think array update is more tricky. Where you write in an imperative language something like $a->[$n]+=$k to update the array element at postition $n, you would in FP (conceptionally) return a copy of the array, which differs from the original one only in the element with index $n. Of course you don't want to actually copy the whole array, unless it is really necessary. For instance, if you have an array $a and a function &fa expecting an array (I stay with Perl syntax here), and you want to invoke the function with $a, but set the first element of $a to zero, the non-functional solution would be simply

      $a->[0]=0; fa($a);
      while a functional solution would need something like
      fa(update($a,0,0))
      and need to be clever enough to not make a copy of the array until this is becomes necessary. But a guess with a clever usage of tied variables and Perl objects, you might indeed be able to come up with a FP framework for Perl...

      -- 
      Ronald Fischer <ynnor@mm.st>
        The lack of side effects is for you of interest for parallel computing or just for theoretical studies?

        > Where you write in an imperative language something like $a->[$n]+=$k to update the array element at postition $n, you would in FP (conceptionally) return a copy of the array, which differs from the original one only in the element with index $n.

        First of all I have to say that LISP doesn't normally use arrays, the normal approach are linked lists, replacing an element is simply done by manipulating the chain, so no big copies needed.

        If you want linked lists and FP mechanisms I strongly recommend reading "Higher Order Perl"!

        Then, the default for passing arrays in perl is by copy, so calling f(@$ar) will not effect the original array. And if you wanna pass arrayrefs you still can write f( [@$ar] ) if you - for whatever reason- don't wanna do the copy within the function.

        The functionality of splice may be of further interest for you.

        Cheers Rolf

Log In?
Username:
Password:

What's my password?
Create A New User
Node Status?
node history
Node Type: note [id://832027]
help
Chatterbox?
and the web crawler heard nothing...

How do I use this? | Other CB clients
Other Users?
Others chilling in the Monastery: (3)
As of 2014-11-28 04:45 GMT
Sections?
Information?
Find Nodes?
Leftovers?
    Voting Booth?

    My preferred Perl binaries come from:














    Results (193 votes), past polls