Parsing .csv into clauses in Haskell - haskell

Question

I am trying to convert a .csv of
femin,femin,1,f,woman,women,
aqu,aqu,1,f,water,waters,
..
into a file of .pl like
noun(femin,femin,1,f,trans(woman,women)).
noun(aqu,aqu,1,f,trans(water,waters)).
..
here is my current source code:
-- get from "femin, femin, 1, f, woman, women" to noun(femin, femin, 1, f ,trans(woman,women)).
import qualified Data.Attoparsec as P
data NounClause = NounClause
{
nom :: String,
gen :: String,
declension :: String,
gender :: String,
sgtrans :: String,
pltrans :: String
} deriving Show
parseNounClause :: P.Parser NounClause
parseNounClause = do
nom <- String
char ","
gen <- String
char ","
declension <- String
char ","
gender <- String
char ","
sgtrans <- String
char ","
pltrans <- String
return $ NounClause nom gen declension gender sgtrans pltrans
However, this does not seem to be working. Why is this so?
Also, how can I apply this parser to each line? Here also is my function that takes the parsed data and returns a string.
c = ","
convert :: NounClause -> String
convert NounClause = "noun(" ++ nom ++ c ++ gen ++ c ++ declension ++ c ++ gender ++ "trans(" ++ sgtrans ++ c ++ pltrans ++ "))."
I very much thank anyone who helps me on this project; their contribution is most valuable to me.

Answer 1

If you use the String parser, it tries to consume as much input as possible. This includes the commas in your file.
So you construct a parser that reads everything except for commas.
import qualified Data.Attoparsec.Text as P
import Data.Text(unpack)
entry = fmap unpack (P.takeWhile (/=','))
unpack is used to convert the parsed info of type Text into a String.
Then you need an additional parser that reads a comma.
separator = P.char ','
Then we combine this to parse a NounClause
parseNounClause :: P.Parser NounClause
parseNounClause = do
nom <- entry
separator -- don't need the comma so no need to keep it.
gen <- entry
separator
declension <- entry
separator
gender <- entry
separator
sgtrans <- entry
separator
pltrans <- entry
separator
return $ NounClause nom gen declension gender sgtrans pltrans
So now you want to read multiple lines. This is the same as the comma but now with a newline symbol.
We parse an entry and a newline symbol alternating. To compensate for n lines but only n-1 newline symbols we make a distinction for the first line. The many' combinator allows us to parse zero or more lines of the same format.
multiLines = do x <- parseNounClause
xs <- many' (do P.endOfLine
clause <- parseNounClause
return clause
)
return (x:xs)
So now wee need to parse this. This is done by the following main Function. For which we need another import, to read the Fileinfo as of type Text
import qualified Data.Text.IO as T(readFile)
main :: IO ()
main = do fileContents <- T.readFile "input.txt"
let result = P.parseOnly multiLines fileContents
case result of (Left s) -> putStrLn s
(Right rs) -> sequence_ (map (putStrLn . show) rs)
The parse result will get us either an error message or all NounClauses in a list. I use sequence_ (map (putStrLn .show) to print it.
You have the function show, which can convert your data type into a String because you added the deriving Show at the end of the definition if you want to use your own String representation instantiate the type class yourself (instead of your convert function) like:
instance Show NounClause where
show n = ...