在Haskell中约束类型级别列表的元素

Question

我试图写一个类型族，可以用来约束类型级别列表的元素。 我有以下代码：

{-# LANGUAGE PolyKinds, DataKinds, TypeOperators, TypeFamilies #-}

import GHC.TypeLits (KnownSymbol, symbolVal)
import GHC.Exts (Constraint)
import Data.Proxy (Proxy(..))

type family AllHave (c :: k -> Constraint) (xs :: [k]) :: Constraint
type instance AllHave c '[] = ()
type instance AllHave c (x ': xs) = (c x, AllHave c xs)

type family Head (xs :: [k]) :: k where
    Head (x ': xs) = x

headProxy :: proxy xs -> Proxy (Head xs)
headProxy _ = Proxy

test :: AllHave KnownSymbol xs => proxy xs -> String
test p = symbolVal (headProxy p)

main :: IO ()
main = putStrLn $ test (Proxy :: Proxy '["a", "b"])

根据我的理解，这应该可行，但是当我编译ghc时会发现：

Test.hs:18:10:
    Could not deduce (KnownSymbol (Head xs))
      arising from a use of ‘symbolVal’
    from the context (AllHave KnownSymbol xs)
      bound by the type signature for
                 test :: AllHave KnownSymbol xs => proxy xs -> String
      at Test.hs:17:9-52
    In the expression: symbolVal (headProxy p)
    In an equation for ‘test’: test p = symbolVal (headProxy p)

Answer 1

这里的问题是，在test馈入xs时Head不会减少，因此Haskell无法从AllHave KnownSymbol xs推导KnownSymbol (Head xs) 。 而且它不应该：如果xs为空应该怎么办？

要解决此问题，您可以像这样明确表明xs不为空：

test :: AllHave KnownSymbol (x ': xs) => proxy (x ': xs) -> String

Answer 2

我对类型族了解不多，所以我将带您参考gallais的答案 ，以解释您的代码出了什么问题。 这是一种非常不同的方法，具有许多演示功能。 可能会有更好的方法； 我不知道。

data CList :: (k -> Constraint) -> [k] -> * where
  CNil :: CList c '[]
  CCons :: c t => proxy t -> CList c ts -> CList c (t ': ts)

mapCSimple :: (forall a . c a => Proxy a -> b) -> CList c as -> [b]
mapCSimple f CNil = []
mapCSimple f (CCons (t :: proxy t) ts) = f (Proxy :: Proxy t) : mapCSimple f ts

toStrings :: CList KnownSymbol v -> [String]
toStrings = mapCSimple symbolVal

class KnownSymbols (xs :: [Symbol]) where
  known :: proxy xs -> CList KnownSymbol xs

instance KnownSymbols '[] where
  known _ = CNil

instance (KnownSymbol x, KnownSymbols xs) => KnownSymbols (x ': xs) where
  known _ = CCons Proxy $ known Proxy

exampleG :: KnownSymbols xs => proxy xs -> String
exampleG p = show . toStrings $ known p

这给

> putStrLn $ exampleG (Proxy :: Proxy '["Hello", "Darkness"])
["Hello","Darkness"]

为了获得更多您想要的东西，

cHead :: CList c (a ': as) -> Dict (c a)
cHead (CCons prox _) = Dict

test :: forall x xs . CList KnownSymbol (x ': xs) -> String
test xs = case cHead xs of Dict -> symbolVal (Proxy :: Proxy x)

test2 :: (KnownSymbols xs, xs ~ (y ': ys)) => proxy xs -> String
test2 prox = test (known prox)

这得到

> putStrLn $ test2 (Proxy :: Proxy '["Hello", "Darkness"])
Hello

这是另一个有趣的功能：

data HList :: (k -> *) -> [k] -> * where
  HNil :: HList f '[]
  HCons :: f a -> HList f as -> HList f (a ': as)

mapC :: (forall a . c a => Proxy a -> f a) -> CList c as -> HList f as
mapC f CNil = HNil
mapC f (CCons (t :: proxy t) ts) = HCons (f (Proxy :: Proxy t)) (mapC f ts)