Re^5: Next Language to Learn

[rovf]

Sorry I didn't intend to criticize you

I didn't interpret it that way ;-)

I'm rather interested to realize different paradigms in Perl, maybe by extending the language.

For instance it would be interesting to see, how easy/clumsy it is to retrofit lazy evaluation into Perl.

With enough pertinacity, every language can be made to look like LISP :-D

[LanX]

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

I'm not fluent in Haskell, so gimme an example and I'll see what's possible.

> With enough pertinacity, every language can be made to look like LISP :-D

Well, unfortunately it's not trivial to realize LISPish macros in Perl 5, otherwise most language extensions I can think of would be easily possible.

Compare Re^2: Dumping variables but DRY and simple for a use case for a macro.

[rovf]

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

[LanX]

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.