Question

我写了一些代码，该代码接受一个异构列表并对其进行索引。

{-# Language GADTs, FunctionalDependencies, MultiParamTypeClasses, KindSignatures, DataKinds, TypeOperators, FlexibleInstances, UndecidableInstances #-}

import Data.Kind

data Nat = Z | S Nat

data Natural a where
  Zero :: Natural 'Z
  Succ :: Natural a -> Natural ('S a)

data HList a where
  EmptyList :: HList '[]
  Cons :: a -> HList b -> HList (a ': b)

class IndexType (n :: Nat) (a :: [Type]) (b :: Type) | n a -> b where
  index :: (Natural n) -> (HList a) -> b

instance IndexType 'Z (a ': b) a where
  index _ (Cons a _) = a

instance IndexType a b c => IndexType ('S a) (d ': b) c where
  index (Succ a) (Cons _ b) = index a b

为此，我实现了自己的Nat和Natural类型。 Nat的存在仅是为了提升到实物级别，而Natural的存在是为了满足类型Nat -> Type。

现在，我宁愿使用GHC.TypeLits'Nat类型，而不是我自己的类型，但是当我尝试翻译我的代码时，我开始在理解方面碰壁。

我想构建我的IndexType类，并且声明行不做任何更改

class IndexType (n :: Nat) (a :: [Type]) (b :: Type) | n a -> b where

由于GHC.TypeLits也有自己的Nat类型。但是，GHC.TypeLits并不能替代Natural，也就是说，我缺少Nat -> Type类型的东西。现在我可以建立一个等效的

data Natural a = Natural

但这实际上与Proxy类型等效，因此我可以改用它。

{-# Language GADTs, FunctionalDependencies, MultiParamTypeClasses, KindSignatures, DataKinds, TypeOperators, FlexibleInstances, UndecidableInstances #-}

import Data.Kind
import GHC.TypeLits
import Data.Proxy

data HList a where
  EmptyList :: HList '[]
  Cons :: a -> HList b -> HList (a ': b)

class IndexType (n :: Nat) (a :: [Type]) (b :: Type) | n a -> b where
  index :: (Proxy n) -> (HList a) -> b

现在IndexType类的第一个实例很简单：

instance IndexType 0 (a ': b) a where
  index _ (Cons a _) = a

但是第二个开始困扰我。第一行似乎是

instance IndexType a b c => IndexType (1 + a) (d ': b) c where

但是在第二行中，我不知道如何替换原始代码中的Succ。 Proxy的数据构造函数为Proxy，所以我想它必须使用该构造函数，所以我必须编写类似以下内容的

  index Proxy (Cons _ b) = index a b

但是现在我要凭空提出a的定义。我想它必须是另一个Proxy，因为索引需要一个Proxy，但是我不知道如何强制它成为正确的类型。

Answer 1

怎么样？

class IndexType (n :: Nat) (a :: [Type]) (c :: Type) | n a -> c where           
  index ::  (Proxy n) -> (HList a) -> c                                         
instance IndexType 0  (a ': b) a where                                          
  index _ (Cons a _) = a                                                        
instance {-# OVERLAPS #-} (IndexType (a-1) b c) => IndexType a (d ': b) c where 
  index _ (Cons _ b) = index (Proxy @(a-1)) b

这将使用一些额外的扩展名，包括ScopedTypeVariables和TypeApplications。 PoC（在GHC 8.2.2上测试）：

{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE UndecidableInstances #-}
{-# LANGUAGE FunctionalDependencies #-}
{-# LANGUAGE GADTs #-}
{-# LANGUAGE DataKinds #-}
{-# LANGUAGE KindSignatures #-}
{-# LANGUAGE TypeOperators #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE TypeApplications #-}

module Foo where
import Data.Kind
import GHC.TypeLits
import Data.Proxy

data HList a where
  EmptyList :: HList '[]
  Cons :: a -> HList b -> HList (a ': b)

class IndexType (n :: Nat) (a :: [Type]) (c :: Type) | n a -> c where
  index ::  (Proxy n) -> (HList a) -> c
instance IndexType 0  (a ': b) a where
  index _ (Cons a _) = a
instance {-# OVERLAPS #-} (IndexType (a-1) b c) => IndexType a (d ': b) c where
  index _ (Cons _ b) = index (Proxy @(a-1)) b

list :: HList '[Int, Bool]
list = Cons (5 :: Int) (Cons True EmptyList)
int :: Int
int = index (Proxy @0) list
bool :: Bool
bool = index (Proxy @1) list

用GHC类型级别的文字替换自建的Naturals

1 个答案: