Parsect | Parser Combinator for TypeScript | Parser library

You can define this with (<$) :: Functor f => a -> f b -> f a. This thus performs a functor mapping with x <$ u = fmap (const x) u:

This change was made March 2, 2009 in commit a98a3ccb by Antoine Latter. The commit comment was just:

As @danidiaz suggested, parser-combinators easily solves the literal problem of permuting ParsecT.

The caveat is that using ParsecT with a Monad m that transforms errors (even its own) isn't particularly useful, other than being able to use fail-fast errors that can't be ignored by <|> and try.

• You can't "demote" the error state of the ParsecT to m's own type of error because (AFAIK) there is no way to access the current error state of the ParsecT.

• ParsecT lacks something comparable to StateT's mapStateT. This means that there is no way to transform an error stored in m without actually executing the parser with runPT (etc.), which isn't possible to do mid-parse.

In summary, ParsecT doesn't leak m in the same way that StateT does, making some of m's functionality inaccessible from within ParsecT.

Parsec is a backtracking monad. While the MonadWriter instance you propose is not impossible, it's a strange thing to put a Writer underneath a backtracking monad. This is because the inner layers of a monad stack provide the "foundational" effects upon which the outer layers build -- that is, whatever ParsecT u (Writer w) does, it must do so only in terms of tell. So if it tells a value in a branch that is later backtracked out of, there is no possibility to "untell" that value, and so the Writer's result will be more like a trace of the parsing algorithm rather than a trace of the dataflow abstraction that Parsec is presenting. It's not useless, but it's pretty odd, and you would have much more natural semantics if WriterT were on the outside and Parsec on the inside.

The same argument applies to State. Parsec exposes both its own user state functionality (the u parameter) and a MonadState instance that inherits the underlying monad's state functionality. The latter comes with the same caveats as MonadWriter -- the statefulness follows the trace of the algorithm, not the dataflow. I don't know why this instance was included while the Writer instance was not; they are both tricky in the same way.

Try this:

Your code does not handle precedences at all, and also as a result of this it uses looping left-recursion.

To give an example of left-recursion in your code, pFunctionType calls pType as the first action, which calls pFunctionType as the first action. This is clearly a loop.

For precedences, I recommend to look at tutorials on "recursive descent operator parsing", a quick Google search reveals that there are several of them. Nevertheless I can summarize here the key points. I write some code.

Here’s what’s happening: uncons needs to run in some sort of monad. You can see this by its type signature: uncons :: Stream s m t => s -> m (Maybe (t, s)). But you’re just doing let x = uncons i — so x is a monadic computation which returns the result of uncons i, but you haven’t specified which monad this monadic computation is running within. You happen to know that you ‘want’ uncons i to run within your monad m (which satisfies Stream s m Char), but GHC doesn’t know this. So GHC makes the assumption that here, uncons i :: m0 (Maybe (t, s)), where m0 is some arbitrary monad. Thus GHC produces the error you see, since uncons requires the constraint Stream s m0 Char to be satisfied in order to use it, yet that constraint isn’t necessarily satisfied for any random m0.

How can this be solved? Well, you already know that this whole computation is of type ParsecT s (ShiftedState u s) m Char, and m satisfies the instance Stream s m Char. And as it turns out, there is a function lift :: Monad m => m a -> ParsecT s u m a which ‘lifts’ a monadic computation m a to a Parsec computation ParsecT s u m a. So you can just rewrite your function to: