[Haskell-cafe] Array, Vector, Bytestring

[silvio]

Hi everyone,

Every time I want to use an array in Haskell, I find myself having to 
look up in the doc how they are used, which exactly are the modules I 
have to import ... and I am a bit tired of staring at type signatures 
for 10 minutes to figure out how these arrays work every time I use them 
(It's even worse when you have to write the signatures). I wonder how 
other people perceive this issue and what possible solutions could be.

Eg. look at the type signature for changing a single entry in an array:

* vector package:
     write :: PrimMonad m => MVector (PrimState m) a -> Int -> a -> m ()
* array package:
     writeArray :: (MArray a e m, Ix i) => a i e -> i -> e -> m ()
* bytestring package:
     not available
* a reasonable type signature would be:
     write :: MVector a -> Int -> a -> ST s a


# To many different implementations

Why do we need so many different implementations of the same thing? In 
the ghc libraries alone we have a vector, array and bytestring package 
all of which do the same thing, as demonstrated for instance by the 
vector-bytestring package. To make matters worse, the haskell 2010 
standard has includes a watered down version of array.

I personally prefer the vector package but if you want to use libraries 
for strings, I am forced back to use bytesting. And now that Array was 
added to haskell 2010, that will start to pop up more and more.

The multitude of already existing libraries is also why I am writing 
this to haskell-cafe and not spinning yet another implementation.

# Index

I don't really see a reason for having an index of a type other than Int 
and that starts somewhere else than at 0.

While there might be corner cases where such a thing might be useful, it 
is only confusing and irritating for the (presumably) rest of us.

# Storable vs Unboxed

Is there really a difference between Storable and Unboxed arrays and if 
so can't this be fixed in the complier rather than having to expose this 
problem to the programmer?

# ST s vs IO

This is probably the hardest to resolve issue. The easiest solution is 
probably to just have a module for each of them as in the array package.
I find the PrimState a bit complicated and circuitous.

The ideal solution would be to have

   type IO a = ST RealWorld# a

in the next haskell standard. If I understand it correctly this would 
let you declare the types as follows but and still use it in an IO context.

   write :: MVector a -> Int -> a -> ST s a

Would this work? I know it would probably screw up all instances

   instance ... IO where

On the other hand, this is not only an issue with arrays but all 
procedurally accelerated data structures like hash-tables.


Silvio