Tamamen bağımlı bir birleştirme oluşturma

Birleştirme hakkında güzel bir gerçek gerçeği, denklemde herhangi bir iki değişken biliyorsanız:

a ++ b = c

Sonra üçüncüyü biliyorum.

Bu fikri kendi aklımda yakalamak istiyorum, böylece işlevsel bir bağımlılık kullanıyorum.

{-# Language DataKinds, GADTs, FlexibleContexts, FlexibleInstances, FunctionalDependencies, KindSignatures, PolyKinds, TypeOperators, UndecidableInstances #-}
import Data.Kind (Type)

class Concatable
   (m  :: k -> Type)
   (as :: k)
   (bs :: k)
   (cs :: k)
   | as bs -> cs
   , as cs -> bs
   , bs cs -> as
   where
     concat' :: m as -> m bs -> m cs

Şimdi ben heterojen liste şöyle çağrıştırın:

data HList ( as :: [ Type ] ) where
  HEmpty :: HList '[]
  HCons  :: a -> HList as -> HList (a ': as)

Ama bunları Concatablebir sorun olarak ilan etmeye çalıştığımda

instance Concatable HList '[] bs bs where
  concat' HEmpty bs = bs
instance
  ( Concatable HList as bs cs
  )
    => Concatable HList (a ': as) bs (a ': cs)
  where
    concat' (HCons head tail) bs = HCons head (concat' tail bs)

Üçüncü fonksiyonel bağımlılığımı tatmin etmiyorum. Daha doğrusu derleyici bizim yapmadığımıza inanıyor. Bunun nedeni, derleyicinin ikinci örneğimizde durumun böyle olabileceğine inanmasıdır bs ~ (a ': cs). Ve eğer durum böyle olabilir Concatable as (a ': cs) cs.

Örneklerimi üç bağımlılığın da karşılanması için nasıl ayarlayabilirim?

Yani, yorumların önerdiği gibi, GHC bunu kendi başına çözmeyecek, ancak biraz tür düzeyinde programlama ile yardımcı olabiliriz. Biraz tanıtalım TypeFamilies. Bu işlevlerin tümü, tür düzeyine yükseltilmiş liste manipülasyonunun oldukça basit çevirileridir:

-- | This will produce the suffix of `cs` without `as`
type family DropPrefix (as :: [Type]) (cs :: [Type]) where
  DropPrefix '[] cs = cs
  DropPrefix (a ': as) (a ': cs) = DropPrefix as cs

-- Similar to the logic in the question itself: list concatenation. 
type family Concat (as :: [Type]) (bs :: [Type]) where
  Concat '[] bs = bs
  Concat (head ': tail) bs = head ': Concat tail bs

-- | Naive list reversal with help of concatenation.
type family Reverse (xs :: [Type]) where
  Reverse '[] = '[]
  Reverse (x ': xs) = Concat (Reverse xs) '[x]

-- | This will produce the prefix of `cs` without `bs`
type family DropSuffix (bs :: [Type]) (cs :: [Type]) where
  DropSuffix bs cs = Reverse (DropPrefix (Reverse bs) (Reverse cs))

-- | Same definition of `HList` as in the question
data HList (as :: [Type]) where
  HEmpty :: HList '[]
  HCons :: a -> HList as -> HList (a ': as)

-- | Definition of concatenation at the value level
concatHList :: (cs ~ Concat as bs) => HList as -> HList bs -> HList cs
concatHList HEmpty bs = bs
concatHList (HCons head tail) bs = HCons head (concatHList tail bs)

Elimizdeki bu araçlar ile aslında saatlik hedefe ulaşabiliriz, ancak önce istenen özelliklere sahip bir işlev tanımlayalım:

• Anlamak yeteneği csgelen asvebs
• Anlamak yeteneği asgelen bsvecs
• Anlamak yeteneği bsgelen asvecs

Voila:

concatH ::
     (cs ~ Concat as bs, bs ~ DropPrefix as cs, as ~ DropSuffix bs cs)
  => HList as
  -> HList bs
  -> HList cs
concatH = concatHList

Test edelim:

foo :: HList '[Char, Bool]
foo = HCons 'a' (HCons True HEmpty)

bar :: HList '[Int]
bar = HCons (1 :: Int) HEmpty

λ> :t concatH foo bar
concatH foo bar :: HList '[Char, Bool, Int]
λ> :t concatH bar foo
concatH bar foo :: HList '[Int, Char, Bool]

Ve son olarak hedef:

class Concatable (m :: k -> Type) (as :: k) (bs :: k) (cs :: k)
  | as bs -> cs
  , as cs -> bs
  , bs cs -> as
  where
  concat' :: m as -> m bs -> m cs

instance (cs ~ Concat as bs, bs ~ DropPrefix as cs, as ~ DropSuffix bs cs) =>
         Concatable HList as bs cs where
  concat' = concatH

λ> :t concat' HEmpty bar
concat' HEmpty bar :: HList '[Int]
λ> :t concat' foo bar
concat' foo bar :: HList '[Char, Bool, Int]
λ> :t concat' bar foo
concat' bar foo :: HList '[Int, Char, Bool]