Am Donnerstag, 24. November 2005 01:49 schrieb Fan Wu:
Hi Wolfgang,
Thanks for your response and examples! It helps a lot.
From your example I can see "Lazy patterns are useful in contexts where infinite data structures are being defined recursively" (quote section 4.4 of Gentle Introduction to Haskell).
They are useful not only in conjunction with infinite data structures. Take my example state transformer "everything" and modify it so that it calls next exactly two times, not infinitely many times, and outputs a pair of the outputs of the two next invocations. Now let's assume you use this pair in a context where only its first component is used. Without lazy patterns, next would be invoked two times although it need to be invoked only one time. So you might have unnecessary evaluation. And you might have something even worse. Let's assume that when we apply the function making up next on the output state of the first next invocation then we get _|_. Without lazy patterns, just using the output of the first next invocation would result in your program aborting. Of course, it shouldn't do so.
But does it apply to the mplus case? I mean the mplus in (mplus m1 m2) and the mplus in (mplus m1' m2') are different due to the difference of Monads (one is StateT s m, the other is just m). If I change the mplus inside lift to something else like:
mplus m1 m2 = do s <- peek let m1' = runState s m1 m2' = runState s m2 ~(a,s') <- lift (other_func m1' m2') poke s' return a
Is it still required that (a,s') be lazy?
I thought a bit about the lazy pattern in the mplus implementation and still don't know if it's necessary. :-(
I just want to see how things works in an less obvious example like this one.
Thanks, Fan
Best wishes, Wolfgang