arrows

[Ashley Yakeley]

At 2002-06-29 14:43, Wolfgang Jeltsch wrote:

>To simplify things a bit, let's take a simpler Parser type which doesn't
>use monad state transformers but simple state transformers instead. This
>makes the type ParserState simpler. You can think of a parser state as
>an infinite list of substate-token pairs now. The tokens denote the
>input stream. The substates may be used to encapsulate parser states of
>a subordinate parsing process. When a token is read, the corresponding
>token-substate pair is discarded.

Sounds very complicated. Wouldn't a simple stream transformer work?

  newtype MyParser baseMonad token output = 
   MkMyParser (baseMonad token -> baseMonad output);

>    (>>=):    sequencing of parsers
>    return:   returning values
>    fail:     generation of always failing parsers
>    mzero:    always failing parser
>    mplus:    parsing using alternative parsers
>    fmap:     applying a function to the result of a parser
>    (>>>):    providing high-level tokens and parsing using these tokens
>    identity: reading a single token
>    pure:     reading a single token and applying a function to it

I think I can do all of those for MyParser. There's a one-token 
look-ahead variant:

  newtype MyLookaheadParser m t a = 
   MkMyLookaheadParser (m t -> Maybe t -> m (Maybe t,a));

>(I don't allow
>finite lists here to make some things a bit easier an more elegant. You
>can easily produce an infinite list from a finite one by applying
>something like (++ repeat Nothing) . map Just to the finite list.)

Wouldn't it be easier to allow finite token lists and have reading past 
the last token be the same as mzero?

-- 
Ashley Yakeley, Seattle WA