haskell - ¿Cuándo quisiera usar un patrón de Monad+intérprete gratis?

monads dsl

Question

Estoy trabajando en un proyecto que, entre otras cosas, implica una capa de acceso a la base de datos. Bastante normal, realmente. En un proyecto anterior, un colaborador me animó a usar el concepto de Mónadas Libres para una capa de base de datos, y así lo hice. Ahora estoy tratando de decidir en mi nuevo proyecto qué es lo que gano.

En el proyecto anterior, tenía una API que se parecía bastante a esto.

saveDocument :: RawDocument -> DBAction ()
getDocuments :: DocumentFilter -> DBAction [RawDocument]
getDocumentStats :: DBAction [(DocId, DocumentStats)]

etc. Alrededor de veinte de esas funciones públicas. Para apoyarlos, tenía la estructura de datos DBAction :

data DBAction a =
      SaveDocument          RawDocument         (DBAction a)
    | GetDocuments          DocumentFilter      ([RawDocument] -> DBAction a)
    | GetDocumentStats                          ([(DocId, DocumentStats)] -> DBAction a)
    | Return a

Y luego una implementación de mónada:

instance Monad DBAction where
    return = Return
    SaveDocument doc k >>= f = SaveDocument doc (k >>= f)
    GetDocuments df k >>= f = GetDocuments df (k >=> f)

Y luego el intérprete. Y luego las funciones primitivas que implementan cada una de las diferentes consultas. Básicamente, siento que tengo una gran cantidad de código de pegamento.

En mi proyecto actual (en un campo totalmente diferente), me he ido con una mónada bastante común para mi base de datos:

newtype DBM err a = DBM (ReaderT DB (EitherT err IO) a)
    deriving (Monad, MonadIO, MonadReader DB)

indexImage :: (ImageId, UTCTime) -> Exif -> Thumbnail -> DBM SaveError ()
removeImage :: DB -> ImageId -> DBM DeleteError ()

Y así. Me imagino que, en última instancia, tendré las funciones "públicas" que representan conceptos de alto nivel que se ejecutan en el contexto de DBM , y luego tendré toda la serie de funciones que hacen el pegamento SQL / Haskell. Esto es, en general, sentirse mucho mejor que el sistema de mónadas gratuito porque no estoy escribiendo una gran cantidad de código repetitivo para no obtener nada más que la capacidad de cambiar mi intérprete.

O...

¿De verdad gané algo más con el patrón Free Monad + Interpreter? ¿Entonces qué?

Answer 1

Como se menciona en los comentarios, a menudo es deseable tener alguna abstracción entre el código y la implementación de la base de datos. Puedes obtener la misma abstracción que una mónada libre definiendo una clase para tu DB Monad (me he tomado algunas libertades aquí):

class (Monad m) => MonadImageDB m where
    indexImage  :: (ImageId, UTCTime) -> Exif -> Thumbnail -> m SaveResult
    removeImage :: ImageId                                 -> m DeleteResult

Si su código está escrito contra MonadImageDB m => lugar de estar estrechamente acoplado a DBM , podrá cambiar la base de datos y el manejo de errores sin modificar su código.

¿Por qué usarías gratis en su lugar? Porque "libera al intérprete tanto como sea posible" , lo que significa que el intérprete solo se compromete a proporcionar una mónada y nada más. Esto significa que usted no tiene restricciones para escribir instancias de mónada para su código. Tenga en cuenta que, para la mónada gratuita, no escribe su propia instancia para Monad , la obtiene de forma gratuita . Escribirías algo como

data DBActionF next =
      SaveDocument     RawDocument    (                            next)
    | GetDocuments     DocumentFilter ([RawDocument]            -> next)
    | GetDocumentStats                ([(DocId, DocumentStats)] -> next)

deriva Functor DBActionF , y obtén la instancia de mónada para Free DBActionF de la instancia existente para Functor f => Monad (Free f) .

Para su ejemplo, sería en cambio:

data ImageActionF next =
      IndexImage  (ImageId, UTCTime) Exif Thumbnail (SaveResult   -> next)
    | RemoveImage ImageId                           (DeleteResult -> next)

También puede obtener la propiedad "libera al intérprete tanto como sea posible" para la clase de tipo. Si no tiene otras restricciones en m que en la clase de tipo, MonadImageDB y todos los métodos de MonadImageDB podrían ser constructores para un Functor , entonces obtendrá la misma propiedad. Puede ver esto implementando la instance MonadImageDB (Free ImageActionF) .

Si va a mezclar su código con interacciones con alguna otra mónada, puede obtener un transformador de mónada de forma gratuita en lugar de una mónada.

Elegir

No tienes que elegir. Puede convertir de ida y vuelta entre las representaciones. Este ejemplo muestra cómo hacerlo para acciones con cero, uno o dos argumentos que devuelven cero, uno o dos resultados. Primero, un poco de repetición

{-# LANGUAGE DeriveFunctor #-}
{-# LANGUAGE FlexibleInstances #-}

import Control.Monad.Free

Tenemos una clase de tipo

class Monad m => MonadAddDel m where
    add  :: String           -> m Int
    del  :: Int              -> m ()
    set  :: Int    -> String -> m ()
    add2 :: String -> String -> m (Int, Int)
    nop ::                      m ()

y una representación de functor equivalente

data AddDelF next
    = Add  String        (       Int -> next)
    | Del  Int           (              next)
    | Set  Int    String (              next)
    | Add2 String String (Int -> Int -> next)
    | Nop                (              next)
  deriving (Functor)

La conversión de la representación libre a la clase de tipo reemplaza a Pure con return , Free con >>= , Add with add , etc.

run :: MonadAddDel m => Free AddDelF a -> m a
run (Pure a) = return a
run (Free (Add  x    next)) = add  x    >>= run . next
run (Free (Del  id   next)) = del  id   >>  run next
run (Free (Set  id x next)) = set  id x >>  run next
run (Free (Add2 x  y next)) = add2 x  y >>= /ids -> run (next (fst ids) (snd ids))
run (Free (Nop       next)) = nop       >>  run next

Una instancia de MonadAddDel para la representación crea funciones para los next argumentos de los constructores que usan Pure .

instance MonadAddDel (Free AddDelF) where
    add  x    = Free . (Add  x   ) $ Pure
    del  id   = Free . (Del  id  ) $ Pure ()
    set  id x = Free . (Set  id x) $ Pure ()
    add2 x  y = Free . (Add2 x  y) $ /id1 id2 -> Pure (id1, id2)
    nop       = Free .  Nop        $ Pure ()

(Ambos tienen patrones que podríamos extraer para el código de producción, la parte más difícil para escribirlos genéricamente sería lidiar con la cantidad variable de argumentos de entrada y resultado)

La codificación en contra de la clase de tipo solo usa la MonadAddDel m => , por ejemplo:

example1 :: MonadAddDel m => m ()
example1 = do
    id <- add "Hi"
    del id
    nop
    (id3, id4) <- add2 "Hello" "World"
    set id4 "Again"

Era demasiado perezoso para escribir otra instancia para MonadAddDel además del que obtuve de forma gratuita, y demasiado perezoso para hacer un ejemplo además de utilizar la clase de tipo MonadAddDel .

Si desea ejecutar un código de ejemplo, esto es suficiente para ver el ejemplo interpretado una vez (convirtiendo la representación de clase de tipo a la representación libre), y de nuevo después de convertir nuevamente la representación libre de nuevo a la representación de clase de tipo. De nuevo, soy demasiado flojo para escribir el código dos veces.

debugInterpreter :: Free AddDelF a -> IO a
debugInterpreter = go 0
    where
        go n (Pure a) = return a
        go n (Free (Add x next)) =
            do
                print $ "Adding " ++ x ++ " with id " ++ show n
                go (n+1) (next n)
        go n (Free (Del id next)) =
            do
                print $ "Deleting " ++ show id
                go n next
        go n (Free (Set id x next)) =
            do
                print $ "Setting " ++ show id ++ " to " ++ show x
                go n next
        go n (Free (Add2 x y next)) =
            do
                print $ "Adding " ++ x ++ " with id " ++ show n ++ " and " ++ y ++ " with id " ++ show (n+1)
                go (n+2) (next n (n+1))
        go n (Free (Nop      next)) =
            do
                print "Nop"
                go n next

main =
    do
        debugInterpreter example1
        debugInterpreter . run $ example1