The Data.Array.* hierarchy is unsafe (or, Segfaulting for fun and profit)

Simon Marlow simonmarhaskell at
Tue Dec 5 05:06:19 EST 2006

Nils Anders Danielsson wrote:
> On Mon, 04 Dec 2006, Simon Marlow <simonmarhaskell at> wrote:
>>  An implementation is entitlesd to assume the following laws about these
>>  operations:
>>   range (l,u) !! index (l,u) i == i -- when i is in scope
>>   inRange (l,u) i == i `elem` range (l,u)
>>   map index (range (l,u)) == [0..rangeSize (l,u)]
> Even if these laws are not satisfied, is the implementation really
> allowed to segfault? I would have guessed that the array operations
> should still be equivalent to some pure Haskell program (e.g.
> undefined).

To me, the wording "An implementation is entitled to assume..." implies that 
there are no obligations on the implementation should the assumption not hold - 
no obligation to yield _|_ or any other behaviour.

> If "laws not satisfied => any behaviour OK" were the correct
> interpretation, then it would be OK for the Array implementation to
> wipe all your files at the first encounter of a broken Ix law... ;)

Yup.  That's not quite as bad as in C, where it's ok for an implementation to 
wipe all your files if you overflow the int type...


More information about the Libraries mailing list