如何将 S 表达式解析为 Haskell 中的数据结构？

Question

我是 Haskell 的新手，需要一些指导。

挑战：获取 S 表达式并将其解析为记录。

我成功的地方：我可以获取一个文件并将其读入一个已解析的字符串。 然而，使用将文本解析为 DFA s.t

 let 
        toDFA :: [L.Text] -> EntryDFA
        toDFA t =
           let [q,a,d,s,f] = t
           in EntryDFA { 
               state = read q
              ,alpha = read a
              ,delta = read d
              ,start = read s
              ,final = read f }

返回此错误：

• Couldn't match type ‘L.Text’ with ‘[Char]’
  Expected type: String
    Actual type: L.Text

必须有更惯用的方法。

Answer 1

read 是一个类型为Read a => String -> a 的偏函数，解析失败时会抛出异常。通常你想避免它（如果你有一个字符串，请使用readMaybe）。 String 和 L.Text 是不同的类型，这就是您收到错误的原因。

您的示例代码在trans-func 之后缺少一个额外的)。

我正在使用 Megaparsec 包，它提供了一种使用解析器组合器的简单方法。库的作者写了更长的教程here。

基本思想是Parser a 是可以解析a 类型的值的类型。在Text.Megaparsec 中，您可以使用几个函数（parse、parseMaybe 等）在“字符串”数据类型（例如String 或严格/惰性Text）上“运行”解析器.

当您对IO 使用do 表示法时，它的意思是“一个接一个地做”。类似地，您可以将do 符号与Parser 一起使用，意思是“先解析这一件事，然后再解析下一件事”。

p1 *> p2表示运行解析器p1，运行p2并返回运行p2的结果。 p1 <* p2 表示运行解析器p1，运行p2 并返回运行p1 的结果。您还可以在 Hoogle 上查找文档，以防您无法理解某些内容。

{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE NamedFieldPuns    #-}

-- In practice, many of these imports would be unqualified, but I've
-- opted for explicitness for clarity.
import Control.Applicative (empty, many, some, (<*), (*>))
import Control.Exception (try, IOException)
import Data.Maybe (fromMaybe)
import Data.Set (Set)
import Data.Text (Text)

import qualified Data.Set as Set
import qualified Data.Text as T
import qualified Data.Text.IO as TIO
import qualified Text.Megaparsec as MP
import qualified Text.Megaparsec.Char as MPC
import qualified Text.Megaparsec.Char.Lexer as MPCL

type Q = Text
type E = Char

data EntryDFA = EntryDFA
  { state :: Set Q
  , alpha :: Set E
  , delta :: Set (Q,E,Q)
  , start :: Q
  , final :: Set Q
  } deriving Show

inputFile = "foo.sexp"

main :: IO ()
main = do
  -- read file and check for exception instead of checking if
  -- it exists and then trying to read it
  result <- try (TIO.readFile inputFile)
  case result of
    Left e -> print (e :: IOException)
    Right txt -> do
      case MP.parse dfaParser inputFile txt of
        Left e -> print e
        Right dfa -> print dfa

type Parser = MP.Parsec () Text

-- There are no comments in the S-exprs, so leave those empty
spaceConsumer :: Parser ()
spaceConsumer = MPCL.space MPC.space1 empty empty

symbol :: Text -> Parser Text
symbol txt = MPCL.symbol spaceConsumer txt

parens :: Parser a -> Parser a
parens p = MP.between (symbol "(") (symbol ")") p

setP :: Ord a => Parser a -> Parser (Set a)
setP p = do
  items <- parens (p `MP.sepBy1` (symbol ","))
  return (Set.fromList items)

pair :: Parser a -> Parser b -> Parser (a, b)
pair p1 p2 = parens $ do
  x1 <- p1
  x2 <- symbol "," *> p2
  return (x1, x2)

stateP :: Parser Text
stateP = do
  c <- MPC.letterChar
  cs <- many MPC.alphaNumChar
  return (T.pack (c:cs))

dfaParser :: Parser EntryDFA
dfaParser = do
  () <- spaceConsumer
  (_, state) <- pair (symbol "states") (setP stateP)
  (_, alpha) <- pair (symbol "alpha") (setP alphaP)
  (_, delta) <- pair (symbol "trans-func") (setP transFuncP)
  (_, start) <- pair (symbol "start") valP
  (_, final) <- pair (symbol "final") (setP valP)
  return (EntryDFA {state, alpha, delta, start, final})
  where
    alphaP :: Parser Char
    alphaP = MPC.letterChar <* spaceConsumer
    transFuncP :: Parser (Text, Char, Text)
    transFuncP = parens $ do
      s1 <- stateP
      a <- symbol "," *> alphaP
      s2 <- symbol "," *> stateP
      return (s1, a, s2)
    valP :: Parser Text
    valP = fmap T.pack (some MPC.digitChar)