New year, new attempt to convert one (1) person to Haskell. Today's weapon: the difference between foldr and foldl.
foldr (&&) True (repeat False) -- False, instantly
foldl (&&) True (repeat False) -- never returns
foldr f z (x:xs) = f x (foldr f z xs). If f does not need its second argument (False && _ is False), the rest of the list is never touched, so even an infinite list is fine.
foldl f z (x:xs) = foldl f (f z x) xs. It walks the whole spine before it can return anything, so on an infinite list it just walks forever.
The other classic:
foldl (+) 0 [1..10000000]
Lazy foldl builds ten million nested thunks (((0+1)+2)+3)... and only evaluates them at the end. With optimisation GHC's strictness analysis often rescues you, but you should not depend on that. Use foldl' from Data.List, which forces the accumulator at each step.
Rule of thumb I teach: foldr when you build a lazy structure or can short-circuit, foldl' when you reduce to a single strict value. Plain foldl is almost never what you want.
Yes, I will mention monads in the replies if nobody else does.