Un modismo que uso para componer un par de procedimientos (con memoria) es el siguiente:

p1 :: State (Int, String) ()
p1 = do
    (a, b) <- get
    ... do something ...
    put (a', b)

p2 :: State (Int, String) ()
p2 = do
    (a, b) <- get
    ... do something else ...
    put (a, b')

main = do
    ... initializing a0 b0 ...
    print . flip evalState (a0, b0)
          . sequence $ replicate 10 p1 ++ repeat p2

Sin embargo, a medida que crece el número de variables de estado, esto se vuelve mucho más detallado de lo necesario:

p1 :: State (Int, String, Bool, Int, String, Bool) ()
p1 = do
    (a, b, c, d, e, f) <- get
    ... do something ...
    put (a, b, c', d, e, f')

p2 :: State (Int, String, Bool, Int, String, Bool) ()
p2 = do
    (a, b, c, d, e, f) <- get
    ... do something ...
    put (a', b', c, d, e, f)

main = do
    print . flip evalState (a0, b0, c0, d0, e0, f0)
          . sequence $ replicate 10 p1 ++ repeat p2

Como me preguntaba, ¿hay alguna forma de actualizar solo unas pocas variables de estado sin tener que hacer referencia a todas las que no se utilizan? Estaba pensando algo comoIORef pero paraState (de hecho hay un paquetestateref), pero no estoy seguro de si ya hay algunos modismos comunes que otras personas han estado usando.