Wiederverwendung von MArray-Instanzen für einen neuen Typ

Ich habe ein Dutzend solcher Newtypes:

newtype MyBool = MyBool Bool
newtype MyInt  = MyInt  Int

Ich möchte vorhandene Instanzen wiederverwenden:

instance MArray IOUArray Int IO         where ...
instance MArray (STUArray s) Int (ST s) where ...

Das Implementieren dieser Instanzen und des gesamten Boilerplate-Codes ist das Letzte, was ich möchte.

Ich habe etwas gefunden, das dem sehr nahe kommt, was ich erreichen möchte:

{-# LANGUAGE GeneralizedNewtypeDeriving, StandaloneDeriving #-}

deriving instance MArray IOUArray MyInt IO      
deriving instance MArray (STUArray s) MyInt (ST s)  

Es schlägt jedoch fehl mit:

Can't make a derived instance of ‘MArray IOUArray MyInt IO’
    (even with cunning GeneralizedNewtypeDeriving):
    cannot eta-reduce the representation type enough
In the stand-alone deriving instance for ‘MArray IOUArray MyInt IO’

Wie funktioniert das?

Wenn nicht möglich, was ist der am wenigsten schmerzhafte Weg, um diese Instanzen zu erhalten?

Aus der Dokumentation :

Wir können sogar Instanzen von Mehrparameterklassen ableiten, vorausgesetzt, der Newtype ist der letzte Klassenparameter.

Beachten Sie auch, dass die Reihenfolge der Klassenparameter wichtig wird, da wir nur Instanzen für die letzte ableiten können. Wenn die StateMonadobige Klasse stattdessen definiert wäre als

class StateMonad m s | m -> s where ...

dann hätten wir keine Instanz für den Parserobigen Typ ableiten können . Wir nehmen an, dass Multiparameterklassen normalerweise einen „Hauptparameter“ haben, für den das Ableiten neuer Instanzen am interessantesten ist.

Da der letzte Klassenparameter in Ihrem Fall nicht Int/ MyInt, sondern IO/ ist ST s, haben Sie GeneralizedNewtypeDerivingleider kein Glück damit .

Okay, Sie stecken hier irgendwie fest, weil einige Designentscheidungen im arrayPaket es schwierig gemacht haben, aber hier ist ein Ansatz, der helfen kann, die Boilerplate zu minimieren.

Sie können eine Typfamilie einführen, um Ihre neuen Typen der zugrunde liegenden Darstellung zuzuordnen:

type family UType e where
  UType MyBool = Bool
  UType MyInt = Int
  UType a = a    -- default for built-in types

und dann neue Typvarianten der Typen IOUArrayund STUArrayArray einführen :

newtype NTSTUArray s i e = NTSTUArray (STUArray s i (UType e))
newtype NTIOUArray i e = NTIOUArray (IOUArray i (UType e))

und verwenden Sie DIESE , um geeignete MArrayInstanzen für Ihre neuen Typen zu erhalten:

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)

Nun sollten Sie in der Lage sein zu verwenden NTIOUArrayund NTSTUArrayanstelle der üblichen IOUArrayund STUArrayfür beide eingebauten und Ihre newtype Elementtypen:

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

Alle IArrayInstanzen können mithilfe der viaAbleitung automatisch generiert werden (was funktioniert, da der Elementtyp das letzte Argument für die IArrayEinschränkung ist):

deriving via MyBool instance IArray UArray MyBool
deriving via MyInt instance IArray UArray MyInt

oder Sie könnten die gleiche Technik wie oben mit einem NTIArrayNewtype verwenden.

Einige Beispielcodes:

{-# 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)