Parsing 如何在没有递归和副作用的情况下为相互递归的ADT编写解析器？

警告：出现了冗长而复杂的问题。

有些人认为这是一个有价值的想法，寻找实现这一想法的技术也是如此。考虑到这一点，我如何为相互递归的ADT编写一个解析器而不产生递归和副作用呢？在这里，我将任何不是递归的术语定义为“递归”

我尝试过的：

注意以下相互递归的ADT：

data Tree = Node Int [Tree]
tree = Node 10 [Node 20 [], Node 30 [], Node 40 []]

值

tree

，可以序列化为：

tree_serial = [0,10,0,0,20,1,0,0,30,1,0,0,40,1,1] :: [Int]

为了简单起见，这里使用int，

0

表示

节点

或

Cons

单元的开始（取决于解析器的状态），1表示

Nil

，其余表示数据。我们可以使用副作用轻松地为其编写解析器：

var string = [0,10,0,0,20,1,0,0,30,1,0,0,40,1,1];

function parse(string){
    function getInt(){
        return string.shift();
    };
    function parseTree(){
        var chr = getInt();
        if (chr === 0)
            return ["Node",getInt(),parseList()];
    };
    function parseList(){
        var chr = getInt();
        if (chr === 0)
            return ["Cons",parseTree(),parseList()];
        if (chr === 1)
            return "Nil";
    };
    return parseTree();
};

console.log(JSON.stringify(parse(string)));

data Tree = Node Int [Tree] deriving Show

parseTree = treeParser Return where
    treeParser = (\ cont -> 
        GetInt (\ _ ->  
            GetInt (\ tag -> 
                listParser (\ listParsingResult -> 
                    (cont (Node tag listParsingResult)))))) 
    listParser = (\ cont -> 
        GetInt (\ a -> 
            if a == 0 
                then treeParser (\x -> listParser (\y -> cont (x : y)))
                else cont []))

main = do
    let treeData = [0,10,0,0,20,1,0,0,30,1,0,0,40,1,1]
    print $ runParser parseTree treeData

这里，

getInt

是副作用的：它从字符串中获取下一个int。我们可以使用Parsec或类似工具轻松优雅地将其转换为Haskell，但为了更好地理解，我跳过了这些，定义了一种精简的解析器类型：

data Parser res = GetInt (Int -> Parser res) | Return res
runParser (GetInt fn) (c:cs) = runParser (fn c) cs
runParser (Return res) c     = res

这与一元解析器的工作原理类似，只是更明确：

main = do
    let parsePair = (GetInt (\a -> (GetInt (\b -> Return (a,b)))))
    print $ runParser parsePair [1,2,3,4,5] 

使用它，我们可以定义解析器，而不会产生副作用：

var string = [0,10,0,0,20,1,0,0,30,1,0,0,40,1,1];

function parse(string){
    function getInt(){
        return string.shift();
    };
    function parseTree(){
        var chr = getInt();
        if (chr === 0)
            return ["Node",getInt(),parseList()];
    };
    function parseList(){
        var chr = getInt();
        if (chr === 0)
            return ["Cons",parseTree(),parseList()];
        if (chr === 1)
            return "Nil";
    };
    return parseTree();
};

console.log(JSON.stringify(parse(string)));

data Tree = Node Int [Tree] deriving Show

parseTree = treeParser Return where
    treeParser = (\ cont -> 
        GetInt (\ _ ->  
            GetInt (\ tag -> 
                listParser (\ listParsingResult -> 
                    (cont (Node tag listParsingResult)))))) 
    listParser = (\ cont -> 
        GetInt (\ a -> 
            if a == 0 
                then treeParser (\x -> listParser (\y -> cont (x : y)))
                else cont []))

main = do
    let treeData = [0,10,0,0,20,1,0,0,30,1,0,0,40,1,1]
    print $ runParser parseTree treeData

这将按预期输出

节点10[节点20[]，节点30[]，节点40[]

。注意，这仍然使用递归，我必须使用

cont

在两个递归函数之间传递控制。现在，我知道有两种策略可以消除递归：

1. Use folds.

2. Use church numbers for bounded recursion.

在这里使用折叠显然是不可行的，因为没有可折叠的结构（我们正在建造它！）。如果我们解析的是一个列表而不是一棵树，那么使用church数字将是完美的，因为它们的工作方式与有界递归的Y组合符完全相同——而且，知道列表的长度，我们可以编写

到church listLength listParser init

。不过，这种情况的问题是，存在相互递归，并且不清楚使用哪个church数。我们有很多层次的列表和长度不可预测的树。事实上，如果我们使用一个足够大的church数，它可以不递归地工作，但要付出额外工作的代价。这是一个非常有用的程序的最后一个例子，如果没有递归，我无法“正确地”复制它。能做到吗

为了完整起见，下面是一个JavaScript程序，它不递归地解析该树，但使用虚构的教堂编号：

function runParser(f){return function(str){
    var a = f(str[0]);
    return a(str.slice(1));
}};
function Const(a){return function(b){return a}};
function toChurch(n){return (function(f){return (function(a){ 
    for (var i=0; i<n; ++i) 
        a  =  f(a); 
    return a; 
}) }) };
function parser(get){
    return toChurch(50)(function(rec){
        return function (res){
            return get(function(a){
                return [get(function(b){
                    return toChurch(50)(function(recl){
                        return function(res){
                            return get(function(a){
                                return [
                                    rec(function(a){
                                        return recl(function(b){
                                            return res(["Cons",a,b])
                                        })
                                    }),
                                    res("Nil")][a];
                            });
                        };
                    })(0)(function(x){return res(["Node",b,x])});
                })][a];
            });
        };
    })(0)(Const);
};
var string = [0,200,0,0,300,0,0,400,1,0,0,500,1,0,0,500,1,1,0,0,600,0,0,700,1,0,0,800,1,0,0,900,1,1,1];
console.log(JSON.stringify(parser(runParser)(string)));

函数runParser（f）{返回函数（str）{
var a=f（str[0]）；
返回一个（str.slice（1））；
}};
函数常数（a）{返回函数（b）{返回a}；
函数toChurch（n）{return（函数（f）{return（函数（a）{
对于（var i=0；itl；dr:Church），对输入列表进行编码，并使用它来驱动递归

正确的列表编码需要
RankNTypes
，看起来有点像这样：

{-# LANGUAGE RankNTypes #-}

data List a = List { runList :: forall r. (a -> r -> r) -> r -> r }
instance Show a => Show (List a) where
    showsPrec n (List xs) = showsPrec n (xs (:) [])

nilVal :: List a
nilVal = List $ \cons nil -> nil

consVal :: a -> List a -> List a
consVal a (List as) = List $ \cons nil -> cons a (as cons nil)

-- handy for pattern-matching
uncons :: List a -> Maybe (a, List a)
uncons (List xs) = xs cons nil where
    cons x Nothing = Just (x, nilVal)
    cons x (Just (x', xs)) = Just (x, consVal x' xs)
    nil = Nothing

现在我们只需要编写语法分析器。我对语法分析器理论非常不熟悉，所以我把一些糟糕的东西放在了一起。也许对该领域有一两点了解的人可以在这里给你一些更有原则的建议。我将解析语法：

tree -> 0 N list
list -> 0 tree list | 1

我的解析器状态将跟踪我们当前正在解析的“孔”。对于非终端，我们实际上需要一堆孔。因此，终端孔有以下形式之一：

* N list
0 * list
* tree list
*

0 N *
0 * list
0 tree *

我们将折叠最后两个。请注意，这些孔前面都没有有趣的信息，因此我们不需要在
孔中存储任何内容。非终端孔有以下形式之一：

* N list
0 * list
* tree list
*

0 N *
0 * list
0 tree *

在这种情况下，树形成规则中的洞前面有一个数字，我们以后需要它，而列表形成规则中的第二类洞前面有一棵树，我们需要保留它，因此
NTHole
将需要构造函数中的树。因此：

data Tree = Node Int [Tree]
    deriving (Eq, Ord, Read, Show)

data THole
    = TreeT0
    | TreeT1
    | ListT
    deriving (Eq, Ord, Read, Show)

data NTHole
    = TreeNT Int
    | ListNT0
    | ListNT1 Tree
    deriving (Eq, Ord, Read, Show)

我们当前的解析器状态将是我们当前所处的终端漏洞，而随着规则的减少，我们需要填充的非终端漏洞堆栈也将减少

type RawState = (THole, List NTHole)
initRawState = (TreeT0, nilVal)

…好吧，除了我们还有两个感兴趣的状态：完成列表和错误

type State = Maybe (Either RawState Tree)
initState = Just (Left initRawState)

现在我们可以编写一个具有良好状态的step函数并对其进行处理。同样，您可能需要一个解析器生成器工具来为您创建其中的一个，但是这种语言非常小，我可以手工完成

stepRaw :: Int -> RawState -> State
stepRaw 0 (TreeT0, xs) = Just (Left (TreeT1, xs))
stepRaw n (TreeT1, xs) = Just (Left (ListT , consVal (TreeNT n) xs))
stepRaw 0 (ListT , xs) = Just (Left (TreeT0, consVal ListNT0    xs))
stepRaw 1 (ListT , xs) = fst (runList xs cons nil) [] where
    cons v (f, xs) = flip (,) (consVal v xs) $ case v of
        ListNT1 t -> \acc -> f (t:acc)
        TreeNT  n -> \acc -> let t = Node n acc in case uncons xs of
            Nothing -> Just (Right t)
            Just (ListNT0, xs) -> Just (Left (ListT, consVal (ListNT1 t) xs))
            _ -> Nothing
        _ -> \acc -> Nothing
    nil = (\acc -> Nothing, nilVal)
stepRaw _ _ = Nothing

step :: Int -> State -> State
step n v = v >>= either (stepRaw n) (const Nothing)

事实证明，这个解析器实际上是向后运行的，这是不幸的，但不是一个基本的限制。我只是更容易朝这个方向思考。根据需要，这里没有递归。我们可以在ghci中的示例
List Int
上试用它

*Main> let x = foldr consVal nilVal [1,1,40,0,0,1,30,0,0,1,20,0,0,10,0]
*Main> runList x step initState
Just (Right (Node 10 [Node 20 [],Node 30 [],Node 40 []]))

我使用
foldr
来构建
x
，而
foldr
是递归的，所以你可能会对此大惊小怪。但是我们可以很容易地定义
x
，而无需
foldr
；内置列表语法比长链的
consVal
和
nilVal
读写起来更方便。你想这样做吗没有递归还是没有显式递归？如果你使用折叠，那么它仍然使用递归，从技术上讲，如果你使用列表，那么你使用的是递归类型（在Haskell中）。如果你知道向量类型的大小，你可以使用它，但在我看来，尝试取消递归数据结构并不是一个很有价值的练习。@bheklillr，我更新了我的问题，使我对“递归函数”的定义更加明确。谢谢！“总计”这并不意味着你不能有递归，甚至不能有无限的东西链。在一个total函数中解析一个无限的字符串是可以的——你只需要corecursion就可以了。所有的total函数都必须是结构递归的（你可以找到一些技巧）或者是高效的（参见示例）.有一个关于总解析器组合器的问题。总解析器组合器…看在上帝的份上，我要退出它，开一辆食品车。这会更容易。我指的是标准形式，在这个意义上，不再对术语进行重新定义，包括内部抽象。也就是说，术语定义为“强规范化”。我发现这是正确的