非常简单的sexp解析器

Question

对于一个赋值，我们必须实现像一个非常基本的sexp解析器，这样的输入，如：

"((a b) ((c d) e) f)"

它将返回：

[["a", "b"], [["c", "d"], "e"], "f"]

由于这是较大任务的一部分，因此解析器仅获得有效输入（匹配的parens和c）。 我在Ruby中提出了以下解决方案：

def parse s, start, stop
  tokens = s.scan(/#{Regexp.escape(start)}|#{Regexp.escape(stop)}|\w+/)

  stack = [[]]

  tokens.each do |tok|
    case tok
    when start
      stack << []
    when stop
      stack[-2] << stack.pop
    else
      stack[-1] << tok
    end
  end

  return stack[-1][-1]
end

这可能不是最好的解决方案，但它可以完成这项工作。

现在，我对一个惯用的Haskell解决方案的核心功能感兴趣（即我不关心lexing或选择分隔符，考虑已经lexed输入会很好），如果可能只使用“核心”haskell，没有扩展或者像parsec这样的库。

请注意，这不是赋值的一部分，我只是对Haskell的处理方式感兴趣。

Answer 1

[["a", "b"], [["c", "d"], "e"], "f"]

haskell中没有有效类型（因为列表中的所有元素都必须在haskell中具有相同的类型），因此您需要为嵌套列表定义自己的数据结构，如下所示：

data NestedList = Value String | Nesting [NestedList]

现在，如果你有令牌列表，其中Token被定义为data Token = LPar | RPar | Symbol String data Token = LPar | RPar | Symbol String data Token = LPar | RPar | Symbol String ，您可以将其解析为NestedList，如下所示：

parse = fst . parse'

parse' (LPar : tokens) =
    let (inner, rest) = parse' tokens
        (next, outer) = parse' rest
    in
      (Nesting inner : next, outer)
parse' (RPar : tokens) = ([], tokens)
parse' ((Symbol str) : tokens) =
    let (next, outer) = parse' tokens in
    (Value str : next, outer)
parse' [] = ([],[])

Answer 2

Haskell中惯用的方法是使用parsec进行组合分析。

网上有很多例子，包括

• 这个关于SO的好答案 。
• 或者这是另一个 。

Answer 3

虽然像Parsec这样的发烧友解析器很不错，但是对于这个简单的情况你并不需要那么强大的功能。 解析的经典方法是使用Prelude中的ReadS类型。 这也是你将Sexp类型作为Read实例的方式。

至少对这种解析方式有点熟悉是很好的，因为标准库中有很多例子。

这是一个经典风格的简单解决方案：

import Data.Char (isSpace)

data Sexp = Atom String | List [Sexp]
  deriving (Eq, Ord)

instance Show Sexp where
  show (Atom a ) = a
  show (List es) = '(' : unwords (map show es) ++ ")"

instance Read Sexp where
  readsPrec n (c:cs) | isSpace c = readsPrec n cs
  readsPrec n ('(':cs)           = [(List es, cs') |
                                      (es, cs') <- readMany n cs]
  readsPrec _ (')':_)            = error "Sexp: unmatched parens"
  readsPrec _ cs                 = let (a, cs') = span isAtomChar cs
                                   in [(Atom a, cs')]

readMany :: Int -> ReadS [Sexp]
readMany _ (')':cs) = [([], cs)]
readMany n cs       = [(e : es, cs'') | (e, cs') <- readsPrec n cs,
                                        (es, cs'') <- readMany n cs']

isAtomChar :: Char -> Bool
isAtomChar '(' = False
isAtomChar ')' = False
isAtomChar c   = not $ isSpace c

请注意，此处不使用通常表示运算符优先级的readsPrec的Int参数。