类型类中的详尽性检查以提升类型

Question

I have promoted type Nat = Suc Nat | Zero Nat = Suc Nat | Zero and I want to make a typeclass class C (a :: Nat) b . Is there a way to convince GHC that instance C Zero b and instance C (Seq x) b covers all cases and therefore I don't need to explicitly declare C as a constraint whenever I use the class' methods. Here is some code:

{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE IncoherentInstances #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE GADTs #-}
{-# LANGUAGE DataKinds #-}
{-# LANGUAGE KindSignatures #-}
{-# LANGUAGE FlexibleContexts #-}
-- Some of these may not be necessary for the particular snippet.

data Nat = Zero | Suc Nat
-- TypeApplications, I know. I am traditional.
data NProxy :: Nat -> * where
  NProxy :: NProxy n

class C (a :: Nat) b where
  f :: NProxy a -> b -> Maybe b

instance C Zero b where
  f _ _ = Nothing
instance C (Suc a) b where
  f _ = Just
-- instance C n b where
--   f = error "This should not have been reached using GetNum."


class C1 a where
  f1 :: a -> Maybe a

instance C1 a where
  f1 = Just

type family GetNum a :: Nat where
  GetNum Char = (Suc Zero)
  GetNum Int = Suc (Suc Zero)
  GetNum [x] = Suc (GetNum x)
  GetNum a = Suc Zero

-- Error:
-- • No instance for (C (GetNum a) a) arising from a use of ‘f’
-- • In the expression: f (NProxy :: NProxy (GetNum a)) x
--   In an equation for ‘noGreet’:
--       noGreet x = f (NProxy :: NProxy (GetNum a)) x
noGreet :: forall a . a -> Maybe a
noGreet x = f (NProxy :: NProxy (GetNum a)) x

-- This one works fine though.
dumb :: a -> Maybe a
dumb = f1

Edit: A related question would be, given the commented out instance if C , why is it when I say noGreet "hi" to the repl I get an exception and not Just "hi" .

Answer 1

noGreet :: forall a . a -> Maybe a

Parametricity says the only definable values of this type are things like

noGreet x = Just x
noGreet x = Nothing
noGreet x = undefined
noGreet x = x `seq` Just x
...

We can't make any choices that depend on the type a , like " Nothing if a is Char otherwise Just x ".

"Tricking the type checker" is a red herring, since what is preventing you from writing such a function is not the type checker, but the fact that information about the type a is simply not available at all at runtime.

---

When you used IncoherentInstances in

noGreet :: forall a . a -> Maybe a
noGreet x = f (NProxy :: NProxy (GetNum a)) x

the compiler had to choose which C instance to use for the call to f , since there is no context provided in the type of noGreet . Naturally the only one that applied was

instance C n b where f = error "This should not have been reached using GetNum."

as the other two instances are too specific to use when we know nothing about a .