I can't seem to figure out how to achieve strictness in the context of the State monad. Consider:
import Control.Monad.State
try count = print final where (_,final) = runState prog 0 prog = sequence_ (replicate count tick)
tick :: State Int Int tick = do n <- get put (n+1) return n
(try 1000000) overflows the stack. It doesn't help to use:
put $! (n+1)
The only way I've been able to get the necessary strictness is to add use of ($!) in the definition of (>>=):
data SState s a = SState (s -> (a,s)) instance Monad (SState s) where return x = SState (\s -> (x,s)) m >>= f = SState (\s -> let SState m' = m (x,s1) = m' s SState f' = f x (y,s2) = f' $! s1 in (y,s2)) runSState (SState m) s = m s sget = SState (\s -> (s,s)) sput s' = SState (\s -> ((),s'))
stry count = print final where (_,final) = runSState prog 0 prog = sequence_ (replicate count stick)
stick :: SState Int Int stick = do n <- sget sput (n+1) return n
Is there no way to get strictness using the standard State monad? Dean