[nem-en] Questions about lazy evaluation

[Kamil Skalski]

Unfortunately with our implementation of lazy values as macros you
need to explicitly give the correct delays to solve the problems.
Those you specified did not do the work, since none of the three calls
to tarai in second branch were not delayed.
The delays which work for me are:

 >>>>>>>>>>>>>>>>>>
using System;
using System.Diagnostics;
using Nemerle;
using Nemerle.IO;

def tarai(x : int, y : int, z : LazyValue[int]) : int {
   if (x <= y) {
       y
   }
   else {
       tarai (
           tarai (x-1, lazy (y), z),
           tarai (y-1, z, lazy (x)),
           lazy (tarai (z-1, lazy (x), lazy (y))))
   }
}

def x = 20;
def y = 10;
def z = 5;

def s = Stopwatch ();

s.Start ();
def a = tarai (x, y, lazy(z));
s.Stop ();

printf("tarai(%d, %d, %d) = %d - %ld\n", x, y, z, a, s.ElapsedMilliseconds);
>>>>>>>>>>>>>>>>>>>>>>>>>>>

Haskell compiler did the stuff for you, but it just proves, that
tracking how such programs are exactly computed is very hard. On the
other hand if you have purely functional function, then you just don't
care about evaluation order.


2006/6/11, mei <mei at work.email.ne.jp>:
> Hi,
>
> There is a Haskell code.
>
> >| tarai.hs : Haskell sample
> main = print (tarai 20 10 5)
>
> tarai :: Int -> Int -> Int -> Int
> tarai x y z = if x <= y then y
>                         else tarai (tarai (x-1) y z)
>                                    (tarai (y-1) z x)
>                                    (tarai (z-1) x y)
> |<
>
> Run very fast above code. Because Haskell is lazy evaluation.  Then I
> notice that Nemerle support lazy evaluation.  I try to convert it to
> Nemerle.
>
> >| tarai.n : Nemerle sample
> using System;
> using System.Diagnostics;
> using Nemerle;
> using Nemerle.IO;
>
> def tarai(x : LazyValue[int], y : LazyValue[int], z : LazyValue[int]) :
> LazyValue [int] {
>     def a : int = x;
>     if (a <= y) {
>         y
>     }
>     else {
>         tarai (
>             tarai (lazy(x-1), y, z),
>             tarai (lazy(y-1), z, x),
>             tarai (lazy(z-1), x, y))
>     }
> }
>
> def x = 20;
> def y = 10;
> def z = 5;
>
> def s = Stopwatch ();
>
> s.Start ();
> def a = tarai (lazy(x), lazy(y), lazy(z));
> s.Stop ();
>
> printf("tarai(%d, %d, %d) = %d - %ld\n", x, y, z, a, s.ElapsedMilliseconds);
>
> |<
>
> But this is very slow.  Can I write faster code like Haskell ?
>
>
> Thanks.
>
> --
> mei <mei at work.email.ne.jp>
>
> _______________________________________________
> https://nemerle.org/mailman/listinfo/devel-en
>


-- 
Kamil Skalski
http://nazgul.omega.pl