Yes, there is a way. I use markdown for writing my entries and it works in the comments as well. Besides that certain HTML tags seem to work. In particular <pre> works fine for code.

do
    start <- many1 hexDigit >>= aChar '-'

Then you can mix in liftM as well:

do
    start <- liftM hexStr2Int $ many1 hexDigit >>= aChar '-'

to do the conversion. However, I think my initial version is even clearer:

do
    start <- liftM hexStr2Int $ many1 hexDigitc
    char '-'

the previous comments have lost many operators in the blog conversion. is there a way to get code through safely, including operators that look html tags?

aChar c r = char c >> return r aSpace = aChar ‘ ‘

… do start <- many1 hexDigit >> aChar ….

note that I haven’t tested this and my haskell-fu is not very strong, so I could be way off here.

parseHexStr = Prelude.read . ("0x" ++)  many1 hexDigit
parsePath   = many1 (char ' ') *> many1 anyChar

parseAddress = Address  hexStr *> char '-'  hexStr 

parseRegion = MemRegion
            parseAddress *> char ' '
            parsePerms   *> char ' '
            parseHexStr  *> char ' '
            parseDevice  *> char ' '
            (Prelude.read  many1 digit) *> char ' '
            (parsePath  return "")

Basicly (liftM# f x y z) can be written as “f x <> y <> z”.

liftM2 f x y = do { u <- x; v <- y; return (f u v) }

Though, that’s a little different from guaranteeing an order of evaluation — depending on the monad, the order of evaluation will vary. In any case, it shouldn’t be much different from what you originally had.

Another thing you might like to play around with, at least in your head, is the fact that:

liftM2 f x y = return f ap x ap y

liftM3 f x y z = return f ap x ap y ap z

and so on, which leads up to the style embodied by the Control.Applicative library, though if you really want to play around with that, you’ll need to write a quick instance of Applicative for GenParser, which should just consist of making pure = return and (<*>) = ap.

parseAddress = let
        hexStr2Int = ...
    in
        liftM2 Address 
            (liftM hexStr2Int $ thenChar '-' $ many1 hexDigit)
            (liftM hexStr2Int $ many1 hexDigit)

I agree with you on readability. I also wonder if laziness could bite back or if liftM2 guarantees an order of evaluation.

your story and Conal’s comment inspired me to play around with liftM and I came up with this version of parseAddress:

parseAddress = let hexStr2Int = Prelude.read . (“0x” ++) in liftM3 (x _ y -> Address (hexStr2Int x) (hexStr2Int y)) (many1 hexDigit) (char ‘-’) (many1 hexDigit)

You could probably rewrite all the functions in a similar way, but honestly I find your original code in do-notation much easier to read.