将.csv解析为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 NounClause s 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 = ...