On Feb 2, 2008 5:28 PM, Antoine Latter wrote:

I'm not a fan of parameterizing the "Stream" class over the monad parameter `m':

...

class Stream s m t | s -> t where uncons :: s -> m (Maybe (t,s))

which leads to instance declarations like so:

...

instance Monad m => Stream [tok] m tok where uncons [] = return $ Nothing uncons (t:ts) = return $ Just (t,ts)

To expand on this point, side-effect instances of Stream don't play nice with the backtracking in Text.Parsec.Prim.try:

import Text.Parsec import Text.Parsec.Prim import System.IO import Control.Monad

type Parser a = (Stream s m Char) => ParsecT s u m a

This particular instance was suggested by Derek.

instance Stream Handle IO Char where uncons hdl = do b <- hIsEOF hdl if b then return Nothing else liftM (\c -> Just (c,hdl)) getChar

testParser :: Parser String testParser = try (string "hello1") <|> string "hello2"

test1 = runPT testParser () "stdin" stdin >>= print test2 = hGetLine stdin >>= print . runP testParser () "stdin"

"test1" uses the (Stream Handle IO Char) instance, "test2" uses the (Monad m => Stream [a] m a) instance. For input "hello2", test2 produces a valid parse while test1 does not. -Antoine

On Sat, 2 Feb 2008, Antoine Latter wrote:

To expand on this point, side-effect instances of Stream don't play nice with the backtracking in Text.Parsec.Prim.try:

...

import Text.Parsec import Text.Parsec.Prim import System.IO import Control.Monad

...

type Parser a = (Stream s m Char) => ParsecT s u m a

This particular instance was suggested by Derek.

<snip> We've been kicking this around on IRC a little, it took me a moment to remember the problem. Basically the problem isn't parsec/try playing badly with the stream - it's the stream playing badly with parsec/try. You need to keep track of where in the file you are and either cache it in an IORef or use seek to jump about appropriately. At the moment, Derek's instance doesn't know where it is in the stream so Parsec's backtracking is invisible to the underlying monad. That caching is the source of the potential leak I mentioned to you, because Parsec doesn't currently tell the stream when it's committed up to a given point and anything preceding it can be dropped safely. We'll tell the list a nice story about this over the coming week. For now, it's nearly 3am here and I should get to bed! -- flippa@flippac.org The task of the academic is not to scale great intellectual mountains, but to flatten them.

On Sun, 3 Feb 2008, Antoine Latter wrote:

Another picky nit:

The monad transformer type is defined as such:

...

data ParsecT s u m a = ParsecT { runParsecT :: State s u -> m (Consumed (m (Reply s u a))) }

with the Consumed and reply types as:

...

data Consumed a = Consumed a | Empty !a

...

data Reply s u a = Ok !a !(State s u) ParseError | Error ParseError

What's the advantage of having a double-wrapping of the base monad `m' over the simpler type:

data ParsecT s u m a = ParsecT { runParsecT :: State s u -> m (Consumed (Reply s u a)) }

It's a necessary part of how Parsec works - both the Consumed and the Reply depend on the input stream, which is now generated from within the base monad. The Consumed result is evaluated in advance of the Reply, so keeping the computations separate preserves an important piece of laziness as m could be a strict monad. For now it's probably a good idea to look for issues that're visible to client code? Turning Parsec into a transformer was long considered an invitation to serious confusion, so it's not surprising that a few things look odd and a few others can be generalised in ways that aren't immediately obvious. -- flippa@flippac.org "The reason for this is simple yet profound. Equations of the form x = x are completely useless. All interesting equations are of the form x = y." -- John C. Baez

On Thu, 7 Feb 2008, Albert Y. C. Lai wrote:

Is it good or bad to add:

instance (MonadIO m) => MonadIO (ParsecT s u m)

I don't see any reason not to add it - it's not as if we can prevent people lifting to IO! Good catch. -- flippa@flippac.org A problem that's all in your head is still a problem. Brain damage is but one form of mind damage.