Aeson解析JSON并使用State将其保存在内存中

Question

I have a "settings" file in my Haskell learning project. It's a JSON file with a basic structure for defining some settings. The settings are now parsed every time when I try to grab something from it. It's reparsed everytime. So I figured I have to keep some State for it that it's been parsed and available.

 parseSettings :: IO Settings
 parseSettings = do
    settingsContent <- B.readFile settingsFile
    let settings = decode settingsContent :: Maybe Settings
    case settings of
        Just s  -> return s
        Nothing -> error "Couldn't parse settings file"

This is the getSetting I am using atm:

getSetting :: (Settings -> a) -> IO a
getSetting f = do
    settings <- parseSettings
    return (f settings)

Now instead of calling parseSettings , I want to actually do something stateful so that I don't have to reparse the settings file everytime I call getSetting . Can anyone recommend me blogposts/articles or any pointers at how to use the State monad for this? (or if there is a simpler way, I'd prefer that).

Answer 1

Unless you need to modify the configuration during the run of your program, it makes more sense to use Reader . You could express your functions using the Reader (or ReaderT , if you need other monads in your stack, like IO etc.) monad and then something like

main :: IO ()
main = do
  s <- parseSettings
  runReader program s

Answer 2

Using StateT you can do

import Control.Monad.State
import Control.Applicative

type App = StateT (Maybe Settings) IO

parseSettings :: IO Settings
parseSettings = undefined  -- Keep your implementation

reloadSettings :: App ()
reloadSettings = do
    settings <- liftIO parseSettings
    put $ Just settings

getSetting :: (Settings -> a) -> App a
getSetting f = get >>= maybe (reloadSettings >> getSetting f) (return . f)

Then you can use this as

data Settings = Settings
    { hostname :: String
    , port :: Int
    } deriving (Eq, Show)

sendRequest :: Request -> App Response
sendRequest request = do
    h <- getSetting hostname
    p <- getSetting port
    liftIO $ do
        hndl <- connect h p
        sendRequest hndl request
        readResponse hndl

And you can run it with

runApp :: App a -> IO a
runApp app = evalStateT app Nothing

This allows you to worry about parsing the settings the first time you call getSetting , and it'll use the current settings after that. If you need to reload the settings just use reloadSettings , and all subsequent commands will use the new settings.

Note that if you want your settings to always be static throughout the application, it's much better to use the Reader monad as Petr shows. This separates the loading of your settings from the running of your application, it has to occur in a two-step process. If you do want to allow the settings to change throughout the application then the State monad is necessary.