I agree with what you meant, but not quite with what you said. To be
pedantic:
import Debug.Trace
foo :: Int
foo = trace Foo (bar 12)
bar :: Int - Int
bar x = trace Bar x
main :: IO ()
main = foo `seq` foo `seq` return ()
main prints Foo\nBar\n showing that the bar is only evaluated
But pedantically even the function:
quux :: Int - Int
quux x = trace Quux (bar 12)
optmain :: IO ()
optmain = quux 10 `seq` quux 11 `seq` return ()
might print only once if GHC at the optimization level selected recognizes
that quux doesn't depend on its argument and rewrote your code
Do I have this right? Remembering Memoization!
For some applications, a lot of state does not to be saved, since
initialization functions can be called early, and these functions
will remember - (memoize) their results when called again, because
of lazy evaluation?
--
Regards,
Casey
On 14/09/2009, at 9:28 AM, Casey Hawthorne wrote:
Do I have this right? Remembering Memoization!
For some applications, a lot of state does not to be saved, since
initialization functions can be called early, and these functions
will remember - (memoize) their results when called again,
