Combining distinct-thread state monads?

[Mark Carroll]

Another bit of code that seems to work is:

convertState :: (s1 -> s2)
	     -> (s2 -> s1)
	     -> State s2 a
	     -> State s1 a

convertState fromState toState computation =
    do oldState <- get
       let (result, newState) =
	       runState computation (fromState oldState)
       put (toState newState)
       return result

Buoyed by this apparent success, I had a go with a Parsec parser:

convertParser :: (s1 -> s2)
	      -> (s2 -> s1)
	      -> GenParser tok s2 a
	      -> GenParser tok s1 a

convertParser fromState toState parser =
    do oldState <- getState
       oldInput <- getInput
       case runParser (wrapParser parser)
		(fromState oldState) "" oldInput of
              Left error ->
		  fail (show error)
              Right (result, newState, newInput) ->
		  do setState (toState newState)
                     setInput newInput
		     return result
    where
    wrapParser parser =
	do result <- parser
	   state <- getState
	   input <- getInput
	   return (result, state, input)

However, this has problems, not least of which are that the source
filepath is lost in the handing down, and the ParseError can't be passed
upward easily without some extra housekeeping, so the resulting shown
error has multiple locations. So maybe composed monads are the way to go.

Is there a better way to do this - with lifting or whatever - *while
keeping the type signatures the same*? (If this has already been said in a
way that wasn't obvious to me the first time, just let me know who said it
and I'll hunt in the list archives.)

-- Mark