De acuerdo, estás un poco atrapado aquí porque algunas opciones de diseño en el array
paquete lo han dificultado, pero aquí hay un enfoque que puede ayudar a minimizar las repeticiones.
Puede introducir una familia de tipos para asignar sus nuevos tipos a su representación subyacente:
type family UType e where
UType MyBool = Bool
UType MyInt = Int
UType a = a -- default for built-in types
y luego introducir newtype variantes de la IOUArray
y STUArray
de la matriz tipos:
newtype NTSTUArray s i e = NTSTUArray (STUArray s i (UType e))
newtype NTIOUArray i e = NTIOUArray (IOUArray i (UType e))
y use ESTOS para obtener MArray
instancias apropiadas para sus nuevos tipos:
instance (MArray (STUArray s) (UType e) (ST s), Coercible e (UType e))
=> MArray (NTSTUArray s) e (ST s) where
getBounds (NTSTUArray arr) = getBounds arr
getNumElements (NTSTUArray arr) = getNumElements arr
newArray (a,b) e = NTSTUArray <$> newArray (a,b) (coerce e)
newArray_ (a,b) = NTSTUArray <$> newArray_ (a,b)
unsafeNewArray_ (a,b) = NTSTUArray <$> unsafeNewArray_ (a,b)
unsafeRead (NTSTUArray arr) i = coerce <$> unsafeRead arr i
unsafeWrite (NTSTUArray arr) i e = unsafeWrite arr i (coerce e)
instance (MArray IOUArray (UType e) IO, Coercible e (UType e))
=> MArray NTIOUArray e IO where
getBounds (NTIOUArray arr) = getBounds arr
getNumElements (NTIOUArray arr) = getNumElements arr
newArray (a,b) e = NTIOUArray <$> newArray (a,b) (coerce e)
newArray_ (a,b) = NTIOUArray <$> newArray_ (a,b)
unsafeNewArray_ (a,b) = NTIOUArray <$> unsafeNewArray_ (a,b)
unsafeRead (NTIOUArray arr) i = coerce <$> unsafeRead arr i
unsafeWrite (NTIOUArray arr) i e = unsafeWrite arr i (coerce e)
Ahora, debería poder usar NTIOUArray
y NTSTUArray
reemplazar el habitual IOUArray
y STUArray
para los tipos de elementos integrados y de tipo newtype:
main = do
x <- newArray (1,10) (MyInt 0) :: IO (NTIOUArray Int MyInt)
y <- newArray (1,10) 0 :: IO (NTIOUArray Int Int)
readArray x 5 >>= writeArray y 8 . coerce
Cualquier IArray
instancia se puede generar automáticamente mediante via
derivación (que funciona porque el tipo de elemento es el último argumento de la IArray
restricción):
deriving via MyBool instance IArray UArray MyBool
deriving via MyInt instance IArray UArray MyInt
o podría usar la misma técnica anterior con un NTIArray
nuevo tipo.
Algún código de muestra:
{-# LANGUAGE DerivingVia, FlexibleContexts, FlexibleInstances, GeneralizedNewtypeDeriving,
MultiParamTypeClasses, StandaloneDeriving, TypeFamilies, UndecidableInstances #-}
import Data.Coerce (coerce, Coercible)
import Data.Array.Base
import Data.Array.IO
import Control.Monad.ST (ST)
newtype MyBool = MyBool Bool deriving (Show)
newtype MyInt = MyInt Int deriving (Show)
-- newtype arrays
type family UType e where
UType MyBool = Bool
UType MyInt = Int
UType a = a
newtype NTSTUArray s i e = NTSTUArray (STUArray s i (UType e))
newtype NTIOUArray i e = NTIOUArray (IOUArray i (UType e))
deriving via MyBool instance IArray UArray MyBool
deriving via MyInt instance IArray UArray MyInt
instance (MArray (STUArray s) (UType e) (ST s), Coercible e (UType e))
=> MArray (NTSTUArray s) e (ST s) where
getBounds (NTSTUArray arr) = getBounds arr
getNumElements (NTSTUArray arr) = getNumElements arr
newArray (a,b) e = NTSTUArray <$> newArray (a,b) (coerce e)
newArray_ (a,b) = NTSTUArray <$> newArray_ (a,b)
unsafeNewArray_ (a,b) = NTSTUArray <$> unsafeNewArray_ (a,b)
unsafeRead (NTSTUArray arr) i = coerce <$> unsafeRead arr i
unsafeWrite (NTSTUArray arr) i e = unsafeWrite arr i (coerce e)
instance (MArray IOUArray (UType e) IO, Coercible e (UType e))
=> MArray NTIOUArray e IO where
getBounds (NTIOUArray arr) = getBounds arr
getNumElements (NTIOUArray arr) = getNumElements arr
newArray (a,b) e = NTIOUArray <$> newArray (a,b) (coerce e)
newArray_ (a,b) = NTIOUArray <$> newArray_ (a,b)
unsafeNewArray_ (a,b) = NTIOUArray <$> unsafeNewArray_ (a,b)
unsafeRead (NTIOUArray arr) i = coerce <$> unsafeRead arr i
unsafeWrite (NTIOUArray arr) i e = unsafeWrite arr i (coerce e)
main = do
x <- newArray (1,10) (MyInt 0) :: IO (NTIOUArray Int MyInt)
y <- newArray (1,10) 0 :: IO (NTIOUArray Int Int)
readArray x 5 >>= writeArray y 8 . coerce
x' <- freeze x :: IO (UArray Int MyInt)
y' <- freeze y :: IO (UArray Int Int)
print $ (x' ! 5, y' ! 8)
foo :: ST s (NTSTUArray s Int MyInt)
foo = newArray (1,10) (MyInt 0)
type role IOUArray nominal nominal
por lo que no podemos coaccionar de array-of-int a array-of-myint. (Me pregunto por qué tenemos tales roles.)