Hi Haskell-Caféists! I have a small DSL for a game. Some instructions have effects (change the game state), some not. -> In short, my question is: how can I semantically separate instructions with effect from the others? i.e. how can I mark down and track those effects? Here is a simplified version of the DSL I use. First some boilerplate:
{-# LANGUAGE GADTs #-} import Control.Monad import Control.Monad.State import Control.Monad.Free
This is the DSL:
data Exp a where ReadAccount :: Exp Int WriteAccount :: Exp Int -> Exp () SetVictory :: Exp Bool -> Exp () OnTimer :: Exp () -> Exp () Return :: a -> Exp a Bind :: Exp a -> (a -> Exp b) -> Exp b
It can read and write to an account (belonging to the state of the game), set a victory condition, and trigger some event every minute.
instance Monad Exp where return = Return (>>=) = Bind
instance Functor Exp where fmap f e = Bind e $ Return . f
With that you can write:
victoryRule :: Exp () victoryRule = SetVictory $ do m <- ReadAccount return (m > 100)
"victoryRule" sets the victory condition to be: "if there is more than 100 gold in the account, you win." This is the game state:
data Game = Game { bankAccount :: Int, victory :: Exp Bool, timerEvent :: Exp ()}
The evaluation of "Exp" can be:
eval :: Exp a -> State Game a eval (SetVictory v) = modify (\g -> g{victory = v}) eval ReadAccount = get >>= return . bankAccount eval _ = undefined -- etc.
If you evaluate "victoryRule", you change the Game state by setting the victory field. Then, each time you will evaluate the victory field, you will know if you won or not (depending on your account...). This is all well and good, but imagine if you write:
victoryRule' :: Exp () victoryRule' = SetVictory $ do m <- ReadAccount WriteAccount (return $ m + 1) return (m > 100)
Ho no! Now each time a player is refreshing his screen (on the web interface), the victory condition is re-evaluated to be displayed again, and the bank account is increased by 1! This is not what we want. We should allow only effect-less (pure) instructions in the victory field, like readAccount, but not WriteAccount. How would you do that? I tried with the Free monad to delimit those effects. I re-write each primitives, marking them with the special type "Effect", when needed.
type Effect = Free Exp
-- readAccount remain the same: it has no effect readAccount :: Exp Int readAccount = ReadAccount
--writeAccount is marked as having an effect writeAccount :: Exp Int -> Effect (Exp ()) writeAccount ei = Pure $ WriteAccount ei
--onTimer is able to trigger an effect every minute onTimer :: Effect (Exp ()) -> Effect (Exp ()) onTimer e = Pure $ OnTimer $ iter join e
--victoryRule can be re-written like this, note that effects are rejected now victoryRule'' :: Effect (Exp ()) victoryRule'' = Pure $ SetVictory $ do m <- readAccount --writeAccount (return $ m + 1) --will be rejected at compile time (good)! return (m > 100)
--increase my bank account by 1 every minute myTimer :: Effect (Exp ()) myTimer = onTimer $ do m <- lift readAccount writeAccount (return $ m + 1)
I don't know if I got it right at all... How does it sound? It only bothers me that in this context "Pure" really means "Impure" :) Do you think of any other solution? Cheers, Corentin