Получение `Show a` из контекста` Show (a, b) `

Если вы не возражаете против ограничения, согласно которому b всегда должен быть экземпляром Show, то это простое решение:

data PairOrNot a where
  Pair :: Show b => (b,c) -> PairOrNot (b,c)
  Not :: a -> PairOrNot a

Я все время пытался понять, смогу ли я придумать что-нибудь получше, и вот лучшее, что я мог придумать:

В своей первоначальной попытке я объединил класс типа Show' с объявлением экземпляра для пар. Несмотря на то, что я не мог найти способ изменить класс типа, мне, по крайней мере, удалось обобщить это для любого объявления экземпляра.

Как указано в комментариях к вопросу, instance (Show a, Show b) => Show (a,b) является односторонним следствием, но я предположил, что его можно применить и в другом направлении, учитывая отсутствие перекрывающихся экземпляров. К сожалению, GHC не полагается на это, но мы можем утверждать это сами. Моя интуиция может быть переведена в код: (:=> от Data.Constraint из пакета constraints, а a :=> b означает, что где-то есть instance a => b)

class Show' a where
  show' :: a -> String
  noOverlap :: (b :=> Show' a) => Proxy a -> Dict b

Здесь функция noOverlap - это обещание, что если вы сможете найти ограничение b, которое порождает экземпляр Show' a, я могу доказать b данный Show' a. Это обещание эквивалентно заявлению о том, что для Show' не будет перекрывающихся экземпляров.

Теперь нам нужна вспомогательная функция для реализации noOverlap

basedOn :: forall k a. (k :=> Show' a, k) => 
             (forall b. (b :=> Show' a) => Proxy a -> Dict b)
basedOn _ = unsafeCoerce (Dict :: Dict k)

Эта функция делает то, что, если вы вызываете ее в контексте, где у вас есть экземпляр k :=> Show' a, она вернет функцию, которая вернет Dict b для любого экземпляра b :=> Show' a. Мы должны использовать unsafeCoerce, чтобы убедить GHC, что Dict k и Dict b одинаковы, но, насколько я могу видеть, это безопасное использование unsafeCoerce, поскольку функциональная зависимость a :=> b | b -> a гарантирует, что может быть только один экземпляр k :=> Show' a для учитывая Show' a.

Теперь, учитывая этого помощника, вот как вы определяете экземпляры

-- An example non-pair instance
instance () :=> Show' Int where ins = Sub Dict 
instance        Show' Int where
  show' i = ""
  noOverlap = basedOn

instance (Show' a, Show' b) :=> Show' (a,b) where ins = Sub Dict
instance (Show' a, Show' b)  => Show' (a,b) where
  show' (a,b) = ""
  noOverlap = basedOn -- GHC does all the plumbing here

Мы должны определить :=> экземпляры вручную, поскольку GHC не делает этого автоматически, но здесь нет места для ошибки. Если мы дадим слишком слабое ограничение слева от заданного вручную :=>, ins = Sub Dict не будет компилироваться, а если мы дадим слишком сильное ограничение, то noOverlap = basedOn не сможет скомпилировать, так что компилятор принудительно заставит шаблон.

Затем мы можем использовать noOverlap следующим образом:

showFirstIfPair :: Show' a => PairOrNot a -> String
showFirstIfPair (Not a) = show' a
showFirstIfPair (Pair a@(b,c)) = 
  -- In this context we have (Show' b, Show' c) :=> Show' a
  case noOverlap Proxy of -- This is a Proxy a
    Dict -> show' b -- This is a Dict (Show' b, Show' c)

Приятно то, что теперь мы также можем перейти, скажем, от Show' [a] к Show' a или любому другому объявлению экземпляра.

Примечание. Для их компиляции вам понадобится {-# LANGUAGE FlexibleContexts, TypeOperators, RankNTypes, ConstraintKinds, AllowAmbiguousTypes #-}.

Вот обобщение user2297560, которое не требует жесткого кодирования Show в GADT:

{-# LANGUAGE ConstraintKinds, KindSignatures #-}
import GHC.Exts (Constraint)

data PairOrNot (cl :: * -> Constraint) (a :: *) where
  Pair :: (cl b, cl c) => (b,c) -> PairOrNot (b,c)
  Not :: cl a => a -> PairOrNot a

Тогда ты можешь

showFirstIfPair :: PairOrNot Show a -> String
showFirstIfPair (Not a) = show a
showFirstIfPair (Pair (b,c)) = show b