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

[Simon Marlow]

Nils Anders Danielsson wrote:
> On Mon, 04 Dec 2006, Simon Marlow <simonmarhaskell at gmail.com> 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...

Cheers,
	Simon