On Thu, Jun 24, 2010 at 9:11 PM, Ivan Miljenovic <ivan.miljenovic@gmail.com> wrote:

On 25 June 2010 10:57, Frank Moore <fmoore@gmail.com> wrote:
> Hello Haskellers,
>
> I am new to programming in Haskell and I am having trouble understanding
> exactly when statements become evaluated. My goal is to try and measure how
> long a computation takes without having to use a show function. The code I
> am trying to use is below (taken in part from RWH chapter 25)
>
> ----------------------------------
> import Data.List (foldl')
> import Data.Time.Clock (diffUTCTime, getCurrentTime)
> import Control.DeepSeq (deepseq)
>
> mean :: [Double] -> Double
> mean xs = s / fromIntegral n where
> (n,s) = foldl' k (0,0) xs
> k (n,s) x = n `seq` s `seq` (n+1,s+x)
>
> main = do
> let as = [1..1e7] :: [Double]
> start <- getCurrentTime
> let meanOver2 = deepseq (mean as) `seq` (mean as) / fromIntegral 2
> end <- getCurrentTime
> putStrLn (show (end `diffUTCTime` start))
> putStrLn (show meanOver2)
> -------------------------------------
>
> My understanding of deepseq was that it evaluates (mean as) completely
> before continuing, and then the show would not take any time, but instead
> all the time is spent in the show meanOver2 function. I feel like I am
> missing something fundamental here. Any suggestions? Thanks for your help.

It does... but because you don't save the result it doesn't keep the
result (you're wanting Common Sub-expression Elimination, which GHC
doesn't do).

Try this:

let meanAs = mean as
meanOver2 = meanAs `deepSeq` meanAs / 2

Note that your usage of "fromIntegral" isn't required, as that is
automatically done for any integral literal (but if you had 2 in an
Int variable then you would need fromIntegral).

--
Ivan Lazar Miljenovic
Ivan.Miljenovic@gmail.com
IvanMiljenovic.wordpress.com