Hi all, I have a function which essentially looks like this: f my_data = do a1 <- newArray ... ... a2 <- newArray ... g my_data a1 a2 where f is a monadic operation essentially of type 'a -> m a'. The problem is that when this function isn't given a type signature, you get something like: f :: (MArray a1 p e, MArray a2 p e) => t where a1 and a2 aren't bound in t. Now, I could provide a type signature on the array expressions, something like: ... (a1 :: IOArray Int Int) <- newArray ... but i would like to be able to use unboxed arrays when possible, and i don't want to bind the funtion to be in IO. My current solution is to define: data ArrayType arr prob = forall ix . ArrayType (arr ix prob) asArray :: arr ix prob -> ArrayType arr prob -> arr ix prob a `asArray` _ = a Sort of like asTypeOf. Then, I change f to: f :: (MArray arr p e) => ArrayType arr p -> t -> m t f arr_type ... = ... And inside f I have a function: newArray_arr bnds init = do a <- newArray bnds init return (a `asArray` arr_type) This enables me to create arrays of arbitrary representation with the same values but different indices (which is important). However, this strikes me as horribly hackish. Is there some better way to do this? - Hal -- Hal Daume III "Computer science is no more about computers | hdaume@isi.edu than astronomy is about telescopes." -Dijkstra | www.isi.edu/~hdaume