Parsec monad transformer with IO?

18 Mar 2010

      Hello!

Nice, Parsec 3 comes with a monad transformer [1]. So I thought I could
use IO as inner monad, and perform IO operations during parsing.

But I failed. Monad transformers still bend my mind. My problem: I
don't see a function to actually lift the IO operation into the
ParsecT. It should be something like

  lift :: IO a -> ParsecT s u IO a

The following is a toy example, I just could not make something
smaller: Let's parse command line arguments (tokens are Strings), and
execute them while parsing.
...
import Text.Parsec.Prim
import Text.Parsec.Pos
import Text.Parsec
import System.Environment ( getArgs )
Command line interface parser (Clip) type: Inner monad IO, user state
u, tokens are Strings, returns something typed a.
...
type Clip u a = ParsecT [String] u IO a
Source code position for command line arguments: The line is always 1,
column n represents the n-th command line argument.
...
nextPos p _ _ = incSourceColumn p 1
Two primitive parsers, one for flags (with a dash) and one for other
arguments:

clipFlag "x" accepts the command line flag "-x", and returns "x".
...
clipFlag :: String -> Clip u String
clipFlag x
    = tokenPrim
      id
      nextPos
      (\y -> if '-':x == y then Just x else Nothing)
clipValue accepts any command line argument that does not tart with a
dash '-'.
...
clipValue :: Clip u String
clipValue
    = tokenPrim id nextPos test
    where
    test ('-':_) = Nothing
    test other = Just other
Now the test program:

Load files given on the command line, and sum up their word count,
until -p is given. -p prints the current word count and sets the
counter to zero. Further files may be processed then. At the end, show
the sum of all word counts.

Example: foo has 12 words, bar has 34 words:

  main foo -p bar -p foo bar -p
  Counted 12 words, reset counter.
  Counted 34 words, reset counter.
  Counted 46 words, reset counter.
  Grand total: 92
...
type CurrentCount = Int -- the user state used with Clip/ParsecT.
root implements the command line grammar (<filename>+ "-p")* and
returns the sum of all word counts.
...
root :: Clip CurrentCount Int
root
    = do ns <- many (many1 loadFile >> printSize)
         eof
         return $ sum ns
Interprets each non-flag on the command line as filename, loads it,
counts its words, and adds the count to the state.
...
loadFile :: Clip CurrentCount ()
loadFile
    = do -- expect a filename
         filename <- clipValue
...
-- load the file: IO
         content <- lift $ readFile filename

...
-- add wordcount to state
         modifyState ((+) (length $ words content))
If -p shows up on the command line, print accumulated count, reset
counter to cero and return count for grand-total calculation.
...
printSize :: Clip CurrentCount Int
printSize
    = do -- expect flag -p
         clipFlag "p"
...
-- print current word count: IO
         n <- getState
         lift . putStrLn $ "Counted "++show n++" words, reset counter."

...
-- reset user state to zero, return word count for grand total
         putState 0
         return n
main just runs the root parser on the command line arguments and
checks the result.
...
main
    = do result <- getArgs >>= runParserT root 0 "command line"
         case result of
           Left err -> error $ show err
           Right n -> putStrLn $ "Grand total: "++show n
So where is the lift function? Does it exist? Here, I need your help.
...
lift :: IO a -> ParsecT s u IO a
lift = undefined
Any comments are appreciated.

Thank you!
Stefan

____________________
[1] http://hackage.haskell.org/packages/archive/parsec/3.0.0/doc/html/Text-Parse...

-- 
Stefan Klinger                                      o/klettern
                                                    /\/  bis zum
send plaintext only - max size 32kB - no spam         \   Abfallen
http://stefan-klinger.de

Stefan Klinger

Gregory Collins

Stefan Klinger

Job Vranish

Andrew Coppin

Stephen Tetley

Andrew Coppin

Daniel Fischer

Luke Palmer

tags

participants (7)