使用megaparsec正确解析嵌套数据

我试图使自己对megaparsec更加熟悉，并且我遇到了一些存在问题。标题中的“嵌套数据”是指我试图解析类型的事实，而类型又可能包含其他类型。如果有人可以解释为什么这种行为不符合我的预期，请不要犹豫告诉我。

我正在尝试解析类似于在Haskell中找到的类型。类型或者是基本类型Int，Bool，Float或类型变量a（任何字小写）。我们还可以从类型构造函数（大写单词）（例如Maybe和类型参数（任何其他类型））构造代数数据类型。例子是Maybe a和Either (Maybe Int) Bool。与权利关联的函数并与->诸如构造Maybe a -> Either Int (b -> c)。N进制元组是的类型由分离的序列,，并包含在(与)，例如(Int, Bool, a)。可以将类型包装在括号中以提高其优先级(Maybe a)。()还定义了单位类型。

我正在使用此ADT对此进行描述。

newtype Ident  = Ident String
newtype UIdent = UIdent String
data Type a
    = TLam a (Type a) (Type a)
    | TVar a Ident
    | TNil a
    | TAdt a UIdent [Type a]
    | TTup a [Type a]
    | TBool a
    | TInt a
    | TFloat a

我试图编写一个megaparsec解析器来解析此类类型，但是得到了意外的结果。我在下面附加了相关代码，之后我将尝试描述我的经验。

{-# LANGUAGE OverloadedStrings #-}
module Parser where

import AbsTinyCamiot

import Text.Megaparsec
import Text.Megaparsec.Char
import qualified Text.Megaparsec.Char.Lexer as Lexer
import Text.Megaparsec.Debug

import Control.Applicative hiding (many, some, Const)
import Control.Monad.Combinators.Expr
import Control.Monad.Identity
import Data.Void
import Data.Text (Text, unpack)

type Parser a = ParsecT Void Text Identity a

-- parse types

pBaseType :: Parser (Type ())
pBaseType = choice [
    TInt   () <$  label "parse int"           (pSymbol "Int"),
    TBool  () <$  label "parse bool"          (pSymbol "Bool"),
    TFloat () <$  label "parse float"         (pSymbol "Float"),
    TNil   () <$  label "parse void"          (pSymbol "()"),
    TVar   () <$> label "parse type variable" pIdent]

pAdt :: Parser (Type ())
pAdt = label "parse ADT" $ do
    con <- pUIdent
    variables <- many $ try $ many spaceChar >> pType
    return $ TAdt () con variables

pType :: Parser (Type ())
pType = label "parse a type" $ 
        makeExprParser 
        (choice [ try pFunctionType
                , try $ parens pType
                , try pTupleType
                , try pBaseType
                , try pAdt
                ]) 
        []--[[InfixR (TLam () <$ pSymbol "->")]]

pTupleType :: Parser (Type ())
pTupleType = label "parse a tuple type" $ do
    pSymbol "("
    fst  <- pType
    rest <- some (pSymbol "," >> pType)
    pSymbol ")"
    return $ TTup () (fst : rest)

pFunctionType :: Parser (Type ())
pFunctionType = label "parse a function type" $ do
    domain <- pType
    some spaceChar
    pSymbol "->"
    some spaceChar
    codomain <- pType
    return $ TLam () domain codomain

parens :: Parser a -> Parser a
parens p = label "parse a type wrapped in parentheses" $ do
    pSymbol "("
    a <- p
    pSymbol ")"
    return a

pUIdent :: Parser UIdent
pUIdent = label "parse a UIdent" $ do
    a <- upperChar
    rest <- many $ choice [letterChar, digitChar, char '_']
    return $ UIdent (a:rest)

pIdent :: Parser Ident
pIdent = label "parse an Ident" $ do
    a <- lowerChar
    rest <- many $ choice [letterChar, digitChar, char '_']
    return $ Ident (a:rest)

pSymbol :: Text -> Parser Text
pSymbol = Lexer.symbol pSpace

pSpace :: Parser ()
pSpace = Lexer.space 
           (void spaceChar) 
           (Lexer.skipLineComment "--") 
           (Lexer.skipBlockComment "{-" "-}")

这可能会让人不知所措，所以让我解释一些关键点。我知道我在开括号上可以匹配很多不同的构造，所以我将这些解析器包装在中try，这样，如果它们失败了，我可以尝试下一个可能占用开括号的解析器。也许我用try得太多了？它会对性能产生很大的潜在影响吗？

我还尝试通过定义一些术语和一个运算符表来制作一个表达式解析器。现在，您可以看到我已经注释掉了运算符（功能箭头）。正如代码现在看起来一样，当我尝试解析函数类型时，我会无限循环。我认为这可能是由于以下事实：当我尝试解析（从中调用pType）函数类型时，我立即尝试解析表示函数域的类型，该函数再次调用pType。我将如何正确执行此操作？

如果我决定改用运算符表，而不是对函数类型使用自定义解析器，则会使用错误的优先级来解析事物。例如Maybe a -> b，解析为Maybe (a -> b)，而我希望将其解析为(Maybe a) -> b。有没有一种方法可以使用运算符表，并使类型构造函数的绑定比功能箭头更紧密？

最后，当我正在学习megaparsec时，如果有人看到任何误解或奇怪/意外的事情，请告诉我。我已经阅读了本教程的大部分内容，以使我了解到这一点。

请告知我为提高问题质量所做的任何修改！