Generic Haskell：确定构造函数是否是递归的

Question

我想编写一些适用于 Haskell 中所有数据类型的函数（至少是 Data.Data 中的所有数据实例）。我遇到的一个普遍问题是根据构造函数是否递归来选择要做什么——递归构造函数是指数据类型是 D，并且有一个构造函数 C，其中一个参数是 D。

我可以通过解决一个更简单的问题来解决上述问题：给定一个数据，确定最外面的构造函数是否是递归的。

这是第 1 次尝试：

data B a = T | F
gIsLeafCons :: (Data a) => a -> B a
gIsLeafCons m = gfoldl (\x y -> F) (\x -> T) m

这个想法是，如果构造函数是递归的，那么我们返回 F，否则我们返回 T。乍一看这很好用：

gIsLeafCons 1 ==> T
gIsLeafCons ([] :: [Int]) ==> T

但是，gfoldl 是多态的，所以给定一个树数据类型比如

data Tree a = Leaf a | Node (Tree a) (Tree a)

我们失败了。

gIsLeafCons (Leaf 1) ==> F

原因是 (Leaf 1) 不是一个真正的空构造函数：它有参数 1，因此应用了构造函数 (\x y -> F)。

第 2 次尝试：

我们可以使用“叶构造函数”，即所有子级都评估为 F。这是一个轻微的改进：

gIsLeafByChild (Leaf 1) ==> T

但是，如果叶子持有不同的递归结构；这将再次失败。

gIsLeafByChild (Leaf (Leaf 1)) ==> F

我真的很想在第一个“叶子构造函数”上停下来，但是 gfoldl 的多态特性使它看起来很难做到这一点，如上所示。

最后，有没有办法判断构造函数是否是“叶构造函数”。我目前的解决方案是让用户传入一个叶子构造函数列表（[Constr]），我只是检查构造函数是否是其中之一。但是，如果有东西在这个列表中，自动推断会很好。

Answer 1

您已经开始使用gfoldl。我们需要做两处改变。首先，当我们遍历结构时，我们需要跟踪每个遇到的类型以查看它们是否递归出现。其次，我们需要递归地使用gfoldl 来查看我们在构造函数中发现的类型。

让我们使用一些实用程序。完成后bool 将得到Bool 结果，bId 会将Bs 从一种类型转换为另一种类型。

{-# LANGUAGE DeriveDataTypeable #-}
{-# LANGUAGE RankNTypes #-}

import Data.Data

data Tree a = Leaf a | Node (Tree a) (Tree a)
    deriving (Data, Typeable)

data B a = T | F

bool :: B a -> Bool
bool T = True
bool F = False   

bId :: B a -> B b
bId T = T
bId F = F

我们可以从Typeable 类中获取类型的表示，或TypeRep。 Typeable 是Data 的超类，所以每当我们有一些a 的Data a 实例时，我们也会有一个Typeable a 实例。我们将通过在[TypeRep] 中携带包含类型表示的列表来跟踪这些。

recursivelyConstructed :: Data a => a -> Bool
recursivelyConstructed = bool . rc []
    where
        cf :: forall d. d -> B d
        cf = const F        
        rc :: forall d. Data d => [TypeRep] -> d -> B d
        rc ts d = gfoldl (rc' (typeOf d:ts)) cf d
        rc' :: forall d b. Data d => [TypeRep] -> B (d -> b) -> d -> B b
        rc' _  T _ = T
        rc' ts F d =
            if elem (typeOf d) ts
            then T
            else bId . rc ts $ d

让我们尝试一些例子

infiniteTree = Node infiniteTree infiniteTree

recursivelyConstructed (Leaf 1                        :: Tree Int) = False
recursivelyConstructed (Node (Leaf 1) (Leaf 2)        :: Tree Int) = True
recursivelyConstructed (infiniteTree                  :: Tree Int) = True
recursivelyConstructed (Leaf (Leaf 1)                 :: Tree (Tree (Int))) = False
recursivelyConstructed (Just (Leaf 1)                 :: Maybe (Tree Int))  = False
recursivelyConstructed (Just (Node (Leaf 1) (Leaf 2)) :: Maybe (Tree Int))  = True
recursivelyConstructed (Just infiniteTree             :: Maybe (Tree Int))  = True
recursivelyConstructed (Just (Leaf (Leaf 1))          :: Maybe (Tree (Tree Int))) = False