Question

As a learning exercise I’m using parsec to look for values in a test file. I’d normally use regexp for this particular case, but want to see if parsec makes sense as well. Unfortunately, I’m running into some problems.

The data file consists of repeating sections that look similar to the following. The ‘SHEF’ is one of six values and changes from page to page, and I want to use it in constructing a data type.

Part A SHEF Nov/14/2011 (10:52)
       -------------------
       Portfolio Valuation
       -------------------

       FOREIGN COMMON STOCK                            6,087,152.65
       FOREIGN COMMON STOCK - USA                      7,803,858.84
       RIGHTS                                                  0.00

I’m constructing a data type of the amounts in each asset class:

type Sector = String
type Amount = Double
type FundCode = String

data SectorAmount = SectorAmount (Sector,Amount) deriving (Show, Eq)

data FundSectors = FundSectors {
      fund             :: FundCode
    , sectorAmounts    :: [SectorAmount]
      } deriving (Show, Eq)

My code, which compiles successfully, is as shown below. It parses the file and correctly retrieves the values in each asset class, but I’m never able to set the state correctly in the fundValue parser. I’ve tested the fundValue parser with an input string and it does successfully parse it, but for some reason the line function isn’t working the way I thought it would. I want it to look for lines in the file which start with “Part A”, find the code and store it in state for later use when the tag parser successfully parses a line.

Is the use of fail causing the problem?

allocationParser :: String -> Either ParseError [FundSectors]
allocationParser input = do
                 runParser allocationFile "" "" input


allocationFile :: GenParser Char FundCode [FundSectors]
allocationFile = do
        secAmt <- many line
        return secAmt


line :: GenParser Char FundCode FundSectors
line = try (do fund <- try fundValue
               eol
               fail "")
       <|> do result <- try tag
              eol
              f <- getState
              return $ FundSectors {fund=f, sectorAmounts = [result]}


fundValue :: GenParser Char FundCode FundCode
fundValue = do manyTill anyChar . try $ lookAhead (string "Part A ")
               string "Part A "
               fCode <- try fundCode
               setState fCode
               v <- many (noneOf "\n\r")
               eol
               return fCode


fundCode :: GenParser Char FundCode String
fundCode = try (string "SHSF")
         <|> try (string "SHIF")
         <|> try (string "SHFF")
         <|> try (string "SHEF")
         <|> try (string "SHGE")
         <|> try (string "SHSE")
         <|> fail "Couldn't match fundCode"


tag :: GenParser Char FundCode SectorAmount
tag = do manyTill anyChar . try $ lookAhead tagName 
         name <- tagName 
         v <- many (noneOf "\n\r")
         let value = read ([x | x <- v, x /= ',']) :: Double -- remove commas from currency
         return $ SectorAmount (name,value)

eol :: GenParser Char FundCode String
eol = try (string "\n\r")
    <|> try (string "\r\n")
    <|> string "\n"
    <|> string "\r"
    <|> fail "Couldn't find EOL"

Thanks in advance.

Answer 1

Yes, the fail in the “try fundValue” block undoes the setState.
You will need to slightly redesign the parser, but you seem close.