Does anybody happen to know why [1.0, 3 ..4 ] is [1.0, 3.0, 5.0] ?

I do realize I'm not supposed to use enumerated lists with doubles, so this is just a question out of pure curiosity. I ran into this example accidentally, and I find it counter-intuitive - I would naively expect that [x, y .. z] does not contain elements greater than z (assuming x < y < z). 

The root cause of why [1.0, 3 .. 4] contains 5.0 is that in the Enum instances for Double and Float, enumFromThenTo is defined like this:

numericEnumFromThenTo e1 e2 e3
    = takeWhile predicate (numericEnumFromThen e1 e2)
                                where
                                 mid = (e2 - e1) / 2
                                 predicate | e2 >= e1  = (<= e3 + mid)
                                           | otherwise = (>= e3 + mid)

and with the concrete values in the example, the predicate becomes (<=5.0).  

My question is this: why can't we simply use (<= e3) as the predicate? Why is the upper limit  (e3) increased by half of the length of the e1 .. e2 interval (mid)? Can someone give an example where using (<=e3) as predicate would give a bad result? 

I'm guessing that the answer has something to do with the quirks of floating-point arithmetic (rounding etc.), of which I'm not an expert at all :)

Regards,

Bence