How to build a custom reader monad along with a custom typeclass?

Question

I'm trying to marry the approach given at http://lexi-lambda.github.io/blog/2016/06/12/four-months-with-haskell/ (section titled "Typeclasses can emulate effects") with some sort of homegrown reader monad.

The overall problem I'm trying to solve is to avoid passing around a configuration variable to almost ever function in my app. And the reason I can't use a ReaderT is because a lot of my functions are in SqlPersistT, which itself uses a ReaderT internally. The other reason is to learn all this mental gymnastics better.

My two questions are given as comments in the code below. Reproducing them here as well:

• What is the most appropriate way to define NwMonad?
• Consequently, how do define NwMonad as an instance of HasNwConfig? How to write the function body of askNwConfig?
• How do I finally call runNwMonad? What will be its arguments?

Here's the code:

data NwConfig = NwConfig {
  _googleClientId :: T.Text,
  _googleClientSecret :: T.Text,
  _tgramBotToken :: String,
  _aria2Command :: String,
  _aria2DownloadDir :: String
  }
$(makeLenses ''NwConfig)

instance Default NwConfig where
  def = NwConfig{}

class MonadIO m => HasNwConfig m where
  askNwConfig :: m NwConfig

startAria2 :: (HasNwConfig m) => m Sytem.Process.ProcessHandle
  cfg <- askNwConfig
  (_, _, _, processHandle) <- createProcess $ proc (cfg ^. aria2Command) []
return processHandle


-- QUESTION: Is this correct?
data NwMonad a = NwMonad{runNwMonad :: (NwConfig -> IO a)}
               deriving (Functor, Applicative, Monad, MonadIO)

-- Or is this the way to do it?
data NwMonad a = NwMonad{runNwMonad :: IO a, nwConfig :: NwConfig}
               deriving (Functor, Applicative, Monad, MonadIO)

instance HasNwConfig NwMonad where
  askNwConfig = return . nwConfig -- QUESTION: How to write this?

main :: IO ()
main = do
  [cId, cSecret, botToken] <- sequence [getEnv "GOOGLE_CLIENT_ID", getEnv "GOOGLE_CLIENT_SECRET", getEnv "TELEGRAM_TOKEN"]
  let cfg = (def :: NwConfig)
        & googleClientId .~ (T.pack cId)
        & googleClientSecret .~ (T.pack cSecret)
        & tgramBotToken .~ botToken
        & aria2Command .~ "/Users/saurabhnanda/projects/nightwatch/aria2-1.19.3/bin/aria2c"
  -- QUESTION: How do I use this now?
  runNwMonad $ (?????) $ startAria2

Answer 1

Here's some code which shows how to work with multiple Reader environments in the same transformer stack. Here BaseMonad is like your SqlPersistT:

import Control.Monad.Reader
import Control.Monad.State
import Control.Monad.IO.Class

type BaseMonad = ReaderT String IO

type NwMonad = ReaderT Int BaseMonad

askString :: NwMonad String
askString =  lift ask

askInt :: NwMonad Int
askInt = ask

startAria :: NwMonad ()
startAria = do
  i <- askInt
  s <- askString
  liftIO $ putStrLn $ "i: " ++ show i ++ " s: " ++ s

main = do
  let cfg = 10       -- i.e. your google client data
      s = "asd"      -- whatever is needed for SqlPersistT
  runReaderT (runReaderT startAria cfg) s

Here's some code using the SqlPersisT type and runSqlConn:

import Control.Monad.Reader
import Control.Monad.State
import Control.Monad.IO.Class
import Database.Persist.Sql

data Config = Config { _clientId :: String }

type BaseMonad = SqlPersistT IO

type NwMonad = ReaderT Config BaseMonad

askBackend:: NwMonad SqlBackend
askBackend =  lift ask

askConfig :: NwMonad Config
askConfig = ask

startAria :: NwMonad ()
startAria = do
  cfg <- askConfig
  liftIO $ putStrLn $ "client id: " ++ (_clientId cfg)

main = do
  let cfg = Config "foobar"
      backend = undefined :: SqlBackend -- however you get this
      sqlComputation = runReaderT startAria cfg :: SqlPersistT IO ()
  runSqlConn sqlComputation backend :: IO ()

Update

The type of the environment doesn't matter.

import Control.Monad.Reader
import Control.Monad.IO.Class

type Level1  =  ReaderT Int IO
type Level2  =  ReaderT Int Level1
type Level3  =  ReaderT Int Level2

ask3 :: Level3 Int
ask3 = ask

ask2 :: Level3 Int
ask2 =  lift ask

ask1 :: Level3 Int
ask1 =  lift $ lift $ ask

doit :: Level3 ()
doit = do
  r1 <- ask1
  r2 <- ask2
  r3 <- ask3
  liftIO $ print (r1, r2, r3)

main = do
  runReaderT (runReaderT (runReaderT doit 333) 222) 111