À la recherche de «instance (enum a, borné a) => iarray uarray a»
Question
Je cherche un moyen d'avoir Enum a => UArray a
(ce qui a du sens pour moi car nous pouvons cartographier à peu près les énumérations Int
et de retour toEnum
et fromEnum
)
Jusqu'à présent, j'ai essayé de voler le code de UArray Int
de Data.array.base et en contrebande quelques-uns toEnum
le sable fromEnum
S ici et là:
{-# LANGUAGE MagicHash, UnboxedTuples #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE FlexibleInstances #-}
module UArrays where
import Data.Array.Base
import Data.Array.ST
import Data.Array.Unboxed
import GHC.Base -- (Int(I#), Int#(..))
import GHC.Prim -- (indexIntArray#, readIntArray#, writeIntArray#)
import GHC.ST (ST(..), runST)
import Unsafe.Coerce
instance (Enum a, Bounded a) => IArray UArray a where
{-# INLINE bounds #-}
bounds (UArray l u _ _) = (l, u)
{-# INLINE numElements #-}
numElements (UArray _ _ n _) = n
{-# INLINE unsafeArray #-}
unsafeArray lu ies = runST (unsafeArrayUArray lu ies minBound)
{-# INLINE unsafeAt #-}
unsafeAt (UArray _ _ _ arr#) (I# i#) =
I# $ fromEnum (indexIntArray# arr# i#)
{-# INLINE unsafeReplace #-}
unsafeReplace arr ies = runST (unsafeReplaceUArray arr ies)
{-# INLINE unsafeAccum #-}
unsafeAccum f arr ies = runST (unsafeAccumUArray f arr ies)
{-# INLINE unsafeAccumArray #-}
unsafeAccumArray f initialValue lu ies =
runST (unsafeAccumArrayUArray f initialValue lu ies)
-- data STUArray s i e = STUArray !i !i !Int (GHC.Prim.MutableByteArray# s)
instance (Enum a, Bounded a) => MArray (STUArray s) a (ST s) where
{-# INLINE getBounds #-}
getBounds (STUArray l u _ _) = return (l, u)
{-# INLINE getNumElements #-}
getNumElements (STUArray _ _ n _) = return n
{-# INLINE unsafeNewArray_ #-}
unsafeNewArray_ (l, u) = unsafeNewArraySTUArray_ (l, u) wORD_SCALE
{-# INLINE newArray_ #-}
newArray_ arrBounds = newArray arrBounds minBound
{-# INLINE unsafeRead #-}
-- unsafeRead :: GHC.Arr.Ix i => a i e -> Int -> m e
unsafeRead (STUArray _ _ _ marr#) (I# i#) =
ST $ \ s1# ->
case readIntArray# marr# i# s1# of
(# s2#, e# #) -> (# s2#, I# (toEnum e#) #)
{-# INLINE unsafeWrite #-}
-- unsafeWrite :: GHC.Arr.Ix i => a i e -> Int -> e -> m ()
unsafeWrite (STUArray _ _ _ marr#) (I# i#) (I# e#) =
ST $ \ s1# ->
case writeIntArray# marr# (unsafeCoerce i#) (I# $ fromEnum e#) s1# of
s2# -> (# s2#, () #)
Mais bien sûr, cela ne se compile pas:
[2 of 4] Compiling UArrays ( UArrays.hs, interpreted )
UArrays.hs:27:14:
Couldn't match expected type `Int#' with actual type `Int'
In the return type of a call of `fromEnum'
In the second argument of `($)', namely
`fromEnum (indexIntArray# arr# i#)'
In the expression: I# $ fromEnum (indexIntArray# arr# i#)
UArrays.hs:52:45:
Couldn't match expected type `Int' with actual type `Int#'
In the first argument of `toEnum', namely `e#'
In the first argument of `I#', namely `(toEnum e#)'
In the expression: I# (toEnum e#)
UArrays.hs:57:57:
Couldn't match expected type `Int#' with actual type `Int'
In the return type of a call of `fromEnum'
In the second argument of `($)', namely `fromEnum e#'
In the third argument of `writeIntArray#', namely
`(I# $ fromEnum e#)'
Failed, modules loaded: Utils.
Il n'y a pas non plus magique unboxInt :: Int -> Int#
dans GHC.*
, et correspondance de motifs sur I#
ne donne pas Int
mais un Int#
Au lieu de cela, pourtant en quelque sorte UArray Int
existe et travaille sur Int#
s.
J'ai aussi trouvé un article sur faire un uarray pour NewTypes, mais cela ne semble pas s'appliquer car il compte unsafeCoerce
. J'ai essayé mais ça a rendu un drôle listArray (0, 54) $ cycle [Red, Yellow, Green]
dans lequel tous les constructeurs étaient Blue
.
Suis-je sur la mauvaise piste?
Mise à jour:
Cela fonctionne maintenant, voici le code source:
- Uarrays.hs: http://hpaste.org/56728
- Benchmarkuarray.hs: http://hpaste.org/56729
- Makefile: http://hpaste.org/56727
Pas de solution correcte