Question

I don’t know whether it is a valid term ‘lazy types’. But still, IO is lazy so in

import Control.Monad
import Data.List

result :: IO Double
result = foldl1' (liftM2 (+)) $ map return [1..10000000]

result' :: IO Double
result' = return $ foldl1' (+) [1..10000000]

result is slow and uses a lot of memory, unlike result'. How shall I fold [IO a] ?

Answer 1

result constructs one big IO Double value without evaluating any of the intermediate results, that only happens when the total result is demanded, e.g. for printing. foldl' evaluates the intermediate results to weak head normal form, that is, to the outermost constructor or lambda. Since (in GHC), IO a has the constructor IO, the intermediate results of the fold have the form

IO (some computation combined with another)

and the expression under the IO gets more complicated at each step.

To avoid that, you have to force not only the intermediate IO values, but also the values that they return,

main :: IO ()
main = foldlM' (\a -> fmap (a+)) 0 (map return [1.0 .. 10000000]) >>= print

foldlM' :: Monad m => (a -> b -> m a) -> a -> [b] -> m a
foldlM' foo a [] = return a
foldlM' foo a (b:bs) = do
    c <- foo a b
    c `seq` foldlM' foo c bs

works for your example.