Haskell 递归类型类

Question

I want to create a recursive instance type based on tuples. What I am looking for is something similar than this:

class Provider a b where
  getInstance :: a -> b

instance Provider a b => Provider (x, a) b where
  getInstance (x, a) = getInstance a

instance Provider (b, x) b where
  getInstance (b, _) = b

tryFunc1 :: Int
tryFunc1 =
  let provider = ("test", (10, ())) :: (String, (Int, ()))
  in getInstance provider

tryFunc2 :: String
tryFunc2 =
  let provider = ("test", (10, ())) :: (String, (Int, ()))
  in getInstance provider

Unfortunatelly, haskell fails to solve the instance. Any reason?

Answer 1

The solution is to stop using the deprecated OverlappingInstances pragma and start using the per instance OVERLAPPING and OVERLAPPABLE pragmas. With just this change:

instance {-# OVERLAPPABLE #-} Provider a b => Provider (x, a) b where
  getInstance (x, a) = getInstance a

instance {-# OVERLAPPING #-} Provider (b, x) b where
  getInstance (b, _) = b

I get tryFunc1 to be 10 and tryFunc2 to be "test" .

---

Technically you only need either the OVERLAPPABLE or OVERLAPPING pragma, but I believe that it is good practice to have both in this case... Also, I suppose this is the behaviour that you want, but note that this just gets the first of whatever type you are looking for (so getInstance (10, (20, ())) :: Int gives me 10 and not 20 )

Good source of info is the ticket tracking the feature's creation.

Answer 2

I know some people don't like UndecidableInstances but that's what I like to do in this type of situation: use a closed type family to make it explicit that the choice is fully deterministic.

The idea is to have the type family compute a boolean flag making it clear which branch should be taken by the typeclass resolution mechanism. The UndecidableInstance extension is needed because of the Provider ab (AtHead ab) => constraint even though it's harmless.

{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE FlexibleInstances     #-}
{-# LANGUAGE FlexibleContexts      #-}
{-# LANGUAGE UndecidableInstances  #-}
{-# LANGUAGE TypeFamilies          #-}
{-# LANGUAGE DataKinds             #-}
{-# LANGUAGE TypeOperators         #-}
{-# LANGUAGE ScopedTypeVariables   #-}

module Provider where

import Data.Proxy
import Data.Type.Equality

class Provider a b (f :: Bool) where
  getInstance' :: Proxy f -> a -> b

type family AtHead x y :: Bool where
  AtHead (x, a) y = x == y

instance Provider a b (AtHead a b) => Provider (x, a) b 'False where
  getInstance' _ (x, a) = getInstance' (Proxy :: Proxy (AtHead a b)) a

instance Provider (b, x) b 'True where
  getInstance' _ (b, _) = b

getInstance :: forall a b. Provider a b (AtHead a b) => a -> b
getInstance = getInstance' (Proxy :: Proxy (AtHead a b))

tryFunc1 :: Int
tryFunc1 =
  let provider = ("test", (10, ())) :: (String, (Int, ()))
  in getInstance provider

tryFunc2 :: String
tryFunc2 =
  let provider = ("test", (10, ())) :: (String, (Int, ()))
  in getInstance provider