Question

我有一个异类型列表（或者至少是我的想法）：

data Nul

data Bits b otherBits where 
    BitsLst :: b -> otherBits -> Bits b otherBits 
    NoMoreBits :: Bits b Nul

现在，给定一个输入类型b，我想要查看Bits类型为b的所有版块并对其进行汇总，忽略类型为b' /= b的其他图块：

class Monoid r => EncodeBit b r | b -> r where 
    encodeBit :: b -> r

class AbstractFoldable aMulti r where 
    manyFold :: r -> aMulti -> r

instance (EncodeBit b r, AbstractFoldable otherBits r) => 
                     AbstractFoldable (Bits b otherBits ) r where 
    manyFold r0 (BitsLst bi other) = manyFold (r0 `mappend` (encodeBit bi)) other
    manyFold b0 NoMoreBits = b0 

instance AbstractFoldable otherBits r =>
                     AbstractFoldable (Bits nb    otherBits ) r where 
    manyFold r0 (BitsLst _ other) = manyFold r0 other
    manyFold b0 NoMoreBits = b0

但编译器不需要它。并且有充分的理由，因为两个实例声明具有相同的头部。问题：使用任意类型折叠Bits的正确方法是什么？

注意：上面的例子是用

编译的

{-# LANGUAGE MultiParamTypeClasses, 
             FunctionalDependencies,
             GADTs,
             DataKinds,
             FlexibleInstances,
             FlexibleContexts
#-}

Answer 1

回答你的评论：

实际上，如果我可以按类型过滤异构列表，我可以这样做。这可能吗？

如果您向Typeable添加b约束，则可以按类型过滤异类列表。

主要想法是我们将使用Data.Typeable的{{3}}来确定列表中的每个项目是否属于某种类型。这将需要对列表中的每个项目Typeable约束。我们将能够检查列表中的All类型是否符合某种约束条件，而不是构建内置此约束的新列表类型。

我们的目标是生成以下程序输出[True,False]，将异构列表过滤为仅Bool个元素。我将努力将语言扩展和导入与

所需的第一个片段放在一起

{-# LANGUAGE DataKinds #-}
{-# LANGUAGE TypeOperators #-}

example :: HList (Bool ': String ': Bool ': String ': '[])
example = HCons True $ HCons "Jack" $ HCons False $ HCons "Jill" $ HNil

main = do
    print (ofType example :: [Bool])

HList这里是使用DataKinds

的haskell中异构列表的相当标准的定义

{-# LANGUAGE GADTs #-}
{-# LANGUAGE KindSignatures #-}

data HList (l :: [*]) where
    HCons :: h -> HList t -> HList (h ': t)
    HNil :: HList '[]

我们希望在ofType上添加一个签名，例如“如果All异构列表中的内容为Typeable，请获取特定Typeable类型的内容列表

import Data.Typeable

ofType :: (All Typeable l, Typeable a) => HList l -> [a]

为此，我们需要在满足某些约束的类型列表中开发All事物的概念。我们将在GADT中存储满足约束条件的字典，它既可以捕获头部约束字典，也可以捕获尾部All的约束，或者证明列表为空。如果我们可以捕获它的字典，则类型列表满足All项的约束。

{-# LANGUAGE MultiParamTypeClasses #-} 
{-# LANGUAGE ConstraintKinds #-}

-- requires the constraints† package.
-- Constraint is actually in GHC.Prim
-- it's just easier to get to this way
import Data.Constraint (Constraint)

class All (c :: * -> Constraint) (l :: [*]) where
    allDict :: p1 c -> p2 l -> DList c l

data DList (ctx :: * -> Constraint) (l :: [*]) where
    DCons :: (ctx h, All ctx t) => DList ctx (h ': t)
    DNil  ::                       DList ctx '[]

DList确实是一个词典列表。 DCons捕获应用于头部项目（ctx h）的约束的字典以及列表其余部分的所有字典（All ctx t）。我们无法直接从构造函数中获取尾部的字典，但我们可以编写一个函数，从All ctx t的字典中提取它们。

{-# LANGUAGE ScopedTypeVariables #-}

import Data.Proxy

dtail :: forall ctx h t. DList ctx (h ': t) -> DList ctx t
dtail DCons = allDict (Proxy :: Proxy ctx) (Proxy :: Proxy t)

空类型列表通常满足应用于其所有项目的任何约束

instance All c '[] where
    allDict _ _ = DNil

如果列表的头部满足约束并且所有尾部都满足，那么列表中的所有内容都满足约束。

{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE UndecidableInstances #-}

instance (c h, All c t) => All c (h ': t) where
    allDict _ _ = DCons

我们现在可以编写ofType，这需要forall s用于ScopedTypeVariables的范围类型变量。

import Data.Maybe

ofType :: forall a l. (All Typeable l, Typeable a) => HList l -> [a]
ofType l = ofType' (allDict (Proxy :: Proxy Typeable) l) l
  where
    ofType' :: forall l. (All Typeable l) => DList Typeable l -> HList l -> [a]
    ofType' d@DCons (HCons x t) = maybeToList (cast x) ++ ofType' (dtail d) t
    ofType' DNil    HNil        = []

我们正在将HList及其词典与maybeToList . cast一起压缩并连接结果。我们可以使用RankNTypes明确说明。

{-# LANGUAGE RankNTypes #-}

import Data.Monoid (Monoid, (<>), mempty)

zipDHWith :: forall c w l p. (All c l, Monoid w) => (forall a. (c a) => a -> w) -> p c -> HList l -> w
zipDHWith f p l = zipDHWith' (allDict p l) l
  where
    zipDHWith' :: forall l. (All c l) => DList c l -> HList l -> w
    zipDHWith' d@DCons (HCons x t) = f x <> zipDHWith' (dtail d) t
    zipDHWith' DNil    HNil        = mempty

ofType :: (All Typeable l, Typeable a) => HList l -> [a]
ofType = zipDHWith (maybeToList . cast) (Proxy :: Proxy Typeable)

†cast :: (Typeable a, Typeable b) => a -> Maybe b

折叠异构编译时列表

1 个答案: