Re^6: Next Language to Learn

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

[rovf]

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