Тестирование, если монада чтения вызывается в неправильной среде

Хотя это кажется немного странным, я полагаю, что одним из способов было бы ввести избыточный ReaderT:

 data EnvironmentA -- = ...
 data EnvironmentB -- = ...

 convertAToB :: EnvironmentA -> EnvironmentB
 convertBToA :: EnvironmentB -> EnvironmentA
 -- convertAToB = ...
 -- convertBToA = ...

 monadA :: MonadReader EnvironmentA m => m Type
 monadA = do
     env <- ask
     -- ...
     res <- runReaderT monadB (convertAToB env)
     -- ...

 monadB :: MonadReader EnvironmentB m => m Type
 monadB = do
     env <- ask
     -- ...
     res <- runReaderT monadA (convertBToA env)
     -- ...

Ваш пример слишком упрощен, чтобы я мог судить, насколько хорошо это применимо, но вы также можете получить его, сделав параметризованным тип Environment. Может быть, GADT, что-то вроде:

data Environment t where
    EnvironmentA :: Environment A
    EnvironmentB :: Environment B

data A
data B

Затем код, который заботится о том, в какой конкретной среде он работает, может иметь ограничение MonadReader (Environment A) m или MonadReader (Environment B) m, а код, который работает с обоими, может использовать ограничение MonadReader (Environment t) m.

Единственным недостатком этого подхода является стандартный недостаток GADT, заключающийся в том, что иногда нужно быть осторожным с ветвями, чтобы убедиться, что у компилятора есть соответствующие доказательства равенства типов. Обычно это можно сделать, но это требует немного больше внимания.

Вот подход, который я бы выбрал. Согласно ответу @Carl, я бы различал среды «A» и «B» на уровне типа, используя GADT, параметризованный «тегом» типа. Использование пары пустых типов для тега (data A и data B, как это сделал @Carl) работает, хотя я предпочитаю использовать DataKinds, потому что это делает намерение более ясным.

Вот предварительные сведения:

{-# OPTIONS_GHC -Wall -Wincomplete-uni-patterns #-}
{-# LANGUAGE DataKinds, GADTs, KindSignatures #-}

import Control.Monad.Reader
import Control.Monad.Random

и вот определение типа среды:

data EnvType = A | B
data Environment (e :: EnvType) where
  EnvironmentA :: Integer -> Environment 'A
  EnvironmentB :: Integer -> Environment 'B

Здесь разные среды имеют одинаковую внутреннюю структуру (т. е. каждая из них содержит Integer), но это не обязательно.

Я собираюсь сделать упрощающее предположение, что ваша монада всегда имеет среду ReaderT в качестве самого внешнего слоя, но мы будем поддерживать полиморфизм в базовой монаде (так что вы можете использовать IO или Gen для обеспечения случайности). Вы можете сделать все это, используя вместо этого ограничения MonadReader, но все усложняется по некоторым неясным техническим причинам (если вам действительно это нужно, добавьте комментарий, и я постараюсь опубликовать дополнительный ответ). То есть для произвольной базовой монады b будем работать в монаде:

type E e b = ReaderT (Environment e) b

Теперь мы можем определить действие mainMonad следующим образом. Обратите внимание на отсутствие ограничения MonadReader, так как об этом заботится подпись E e b Type. Ограничение MonadRandom b базовой монады гарантирует, что E e b будет иметь экземпляр MonadRandom. Поскольку сигнатура E e b Type полиморфна в e :: EnvType, mainMonad может работать с любым типом среды. Путем сопоставления регистра в среде GADT он может ввести ограничения e ~ 'A и т. д. в область видимости, что позволит отправлять его в monadA и т. д.

data Type = Type [String]  -- some return type

mainMonad ::
  ( MonadRandom b )
    => E e b Type
mainMonad = do
  env <- ask
  case env of
    EnvironmentA _ -> monadA
    EnvironmentB _ -> monadB

Сигнатуры типов для monadA и monadB похожи, хотя они исправляют EnvType:

monadA ::
  ( MonadRandom b )
    => E 'A b Type
monadB ::
  ( MonadRandom b )
    => E 'B b Type

Действие monadA может вызывать специфичное для A helperA, а также обычное helper:

monadA = do
  result1 <- helperA
  result2 <- helper
  return $ Type [result1,  result2]

Помощники могут использовать средства MonadRandom и проверять среду, используя такие функции, как getData, которые соответствуют регистру в среде.

helperA :: (Monad b) => E 'A b String -- we don't need MonadRandom on this one
helperA = do
  n <- asks getData
  return $ show n
helper :: (MonadRandom b) => E e b String
helper = do
  n <- asks getData
  x <- getRandomR (0,n)
  return $ show x
getData :: Environment e -> Integer
getData (EnvironmentA x) = x
getData (EnvironmentB x) = x

Также возможно непосредственное сопоставление регистра в среде. В обычном помощнике необходимо обрабатывать все типы среды, но в помощнике, специфичном для EnvType, нужно обрабатывать только тот EnvType (т. е. совпадение с шаблоном будет исчерпывающим, поэтому даже при -Wall не будет генерироваться предупреждение о несовпадающих случаях). ):

helper2 :: (Monad b) => E e b String
helper2 = do
  env <- ask
  case env of
    -- all cases must be handled or you get "non-exhaustive" warnings
    EnvironmentA n -> return $ show n ++ " with 'A'-appropriate processing"
    EnvironmentB n -> return $ show n ++ " with 'B'-appropriate processing"
helperA2 :: (Monad b) => E 'A b String
helperA2 = do
  env <- ask
  case env of
    -- only A-case need be handled, and trying to match B-case generates warning
    EnvironmentA n -> return $ show n

Действие monadB может вызывать общие помощники и может отправляться в monadA с соответствующим вызовом withReaderT.

monadB = do
  Type start <- withReaderT envBtoA monadA
  result <- helper
  return $ Type $ start ++ [result]

envBtoA :: Environment 'B -> Environment 'A
envBtoA (EnvironmentB x) = EnvironmentA x

Самое главное, конечно, что вы не можете случайно вызвать действие типа A из действия типа B:

badMonadB ::
  ( MonadRandom b )
    => E 'B b Type
badMonadB = do
  monadA  -- error: couldn't match A with B

вы также не можете случайно вызвать действие A-типа из универсального помощника:

-- this is a common helper
badHelper :: (Monad b) => E e b String
badHelper = do
  -- so it can't assume EnvironmentA is available
  helperA  -- error: couldn't match "e" with B

хотя вы можете использовать сопоставление регистра, чтобы проверить подходящую среду, а затем отправить:

goodHelper :: (Monad b) => E e b String
goodHelper = do
  env <- ask
  case env of
    EnvironmentA _ -> helperA  -- if we're "A", it's okay
    _              -> return "default"

Я чувствую, что должен указать на относительные преимущества и недостатки этого решения @DanielWagner (которое, я думаю, вы неправильно поняли).

Его решение:

• обеспечивает безопасность типов. Если вы попытаетесь вставить res <- monadB в определение monadA, он не наберет проверку.
• не предоставляет, как написано, механизм для определения общих вспомогательных функций, которые обращаются к среде (обычные вспомогательные функции, которым требуется только MonadRandom, будут работать нормально), но это можно сделать, введя класс типов с экземплярами для EnvironmentA и EnvironmentB, которые предоставляют методы для делать все, что обычно хелперы могут делать с окружением
• требует специальной обработки среды в mainMonad (хотя есть некоторые вопросы о том, зачем вам вообще нужен mainMonad)
• избегает сложного обмана на уровне типов, поэтому с ним может быть проще работать
• Я полагаю, что добавляет дополнительный слой ReaderT при каждом переходе среды, поэтому может возникнуть штраф во время выполнения, если существует глубокая рекурсивная вложенность A-to-B-to-A-to-B.

Чтобы увидеть их рядом, вот мое полное решение:

{-# OPTIONS_GHC -Wall -Wincomplete-uni-patterns #-}
{-# LANGUAGE DataKinds, GADTs, KindSignatures #-}

import Control.Monad.Reader
import Control.Monad.Random

data EnvType = A | B
data Environment (e :: EnvType) where
  EnvironmentA :: Integer -> Environment 'A
  EnvironmentB :: Integer -> Environment 'B
getData :: Environment e -> Integer
getData (EnvironmentA x) = x
getData (EnvironmentB x) = x

type E e b = ReaderT (Environment e) b

data Type = Type [String]  -- some return type

mainMonad :: (MonadRandom b) => E e b Type
mainMonad = do
  env <- ask
  case env of
    EnvironmentA _ -> monadA
    EnvironmentB _ -> monadB

monadA :: (MonadRandom b) => E 'A b Type
monadA = do
  result1 <- helperA
  result2 <- helper
  return $ Type [result1,  result2]

monadB :: (MonadRandom b) => E 'B b Type
monadB = do
  Type start <- withReaderT envBtoA monadA
  result <- helper
  return $ Type $ start ++ [result]
envBtoA :: Environment 'B -> Environment 'A
envBtoA (EnvironmentB x) = EnvironmentA x

helperA :: (Monad b) => E 'A b String -- we don't need MonadRandom on this one
helperA = do
  n <- asks getData
  return $ show n

helper :: (MonadRandom b) => E e b String
helper = do
  n <- asks getData
  x <- getRandomR (0,n)
  return $ show x

а вот его вариант:

{-# OPTIONS_GHC -Wall -Wincomplete-uni-patterns #-}
{-# LANGUAGE FlexibleContexts #-}

import Control.Monad.Reader
import Control.Monad.Random

data EnvType = A | B
data EnvironmentMain = EnvironmentMain EnvType Integer
data EnvironmentA = EnvironmentA Integer
data EnvironmentB = EnvironmentB Integer

class Environment e where getData :: e -> Integer
instance Environment EnvironmentA where getData (EnvironmentA n) = n
instance Environment EnvironmentB where getData (EnvironmentB n) = n

convertAToB :: EnvironmentA -> EnvironmentB
convertAToB (EnvironmentA x) = EnvironmentB x
convertBToA :: EnvironmentB -> EnvironmentA
convertBToA (EnvironmentB x) = EnvironmentA x

data Type = Type [String]  -- some return type

mainMonad :: (MonadReader EnvironmentMain m, MonadRandom m) => m Type
mainMonad = do
  env <- ask
  case env of
    EnvironmentMain A n -> runReaderT monadA (EnvironmentA n)
    EnvironmentMain B n -> runReaderT monadB (EnvironmentB n)

monadA :: (MonadReader EnvironmentA m, MonadRandom m) => m Type
monadA = do
  result1 <- helperA
  result2 <- helper
  return $ Type $ [result1] ++ [result2]

monadB :: (MonadReader EnvironmentB m, MonadRandom m) => m Type
monadB = do
  env <- ask
  Type start <- runReaderT monadA (convertBToA env)
  result <- helper
  return $ Type $ start ++ [result]

helperA :: (MonadReader EnvironmentA m) => m String
helperA = do
  EnvironmentA n <- ask
  return $ show n

helper :: (Environment e, MonadReader e m, MonadRandom m) => m String
helper = do
  n <- asks getData
  x <- getRandomR (0,n)
  return $ show x