Почему «трюк с ограничениями» не работает в этом экземпляре HasField, заданном вручную?

У меня есть этот (по общему признанию странный) код, который использует lens и GHC.Records :

{-# LANGUAGE DataKinds, PolyKinds, FlexibleInstances, UndecidableInstances #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE TypeApplications #-}
{-# LANGUAGE TypeFamilies #-}
module Main where
import Control.Lens
import GHC.Records 

data Glass r = Glass -- just a dumb proxy

class Glassy r where
  the :: Glass r

instance Glassy x where
  the = Glass

instance (HasField k r v, x ~ r)
-- instance (HasField k r v, Glass x ~ Glass r) 
  => HasField k (Glass x) (ReifiedGetter r v) where
  getField _ = Getter (to (getField @k))

data Person = Person { name :: String, age :: Int } 

main :: IO ()
main = do
  putStrLn $ Person "foo" 0 ^. runGetter (getField @"name" the)

Идея состоит в том, чтобы иметь HasFieldэкземпляр, который вызывает заклинание ReifiedGetterиз прокси, просто для этого. Но это не работает:

* Ambiguous type variable `r0' arising from a use of `getField'
  prevents the constraint `(HasField
                              "name"
                              (Glass r0)
                              (ReifiedGetter Person [Char]))' from being solved.

Я не понимаю, почему r0остается неоднозначным. Я использовал трюк с ограничением , и моя интуиция заключается в том, что заголовок экземпляра должен совпадать, тогда проверщик типов найдет r0 ~ Personв предварительных условиях, и это устранит неоднозначность.

Если я перехожу (HasField k r v, x ~ r)на это, (HasField k r v, Glass x ~ Glass r)это устраняет неоднозначность и компилируется нормально. Но почему это работает, и почему это не работает по-другому?

Возможно удивительно, это имело отношение к тому, чтобы Glassбыть многогранным:

*Main> :kind! Glass
Glass :: k -> *

Между тем, в отличие от параметра типа Glass, «запись» HasFieldдолжна быть такой Type:

*Main> :set -XPolyKinds
*Main> import GHC.Records
*Main GHC.Records> :kind HasField
HasField :: k -> * -> * -> Constraint

Если я добавлю отдельную добрую подпись, как это:

{-# LANGUAGE StandaloneKindSignatures #-}
import Data.Kind (Type)
type Glass :: Type -> Type
data Glass r = Glass

Затем он проверяет даже с (HasField k r v, x ~ r).

Фактически, с доброй подписью, «уловка ограничения» перестает быть необходимой:

instance HasField k r v => HasField k (Glass r) (ReifiedGetter r v) where
  getField _ = Getter (to (getField @k))

main :: IO ()
main = do
  print $ Person "foo" 0 ^. runGetter (getField @"name" the)
  print $ Person "foo" 0 ^. runGetter (getField @"age" the)

Здесь поток информации во время проверки типов выглядит следующим образом:

• Мы знаем, что у нас есть Person, так что - через runGetter- тип поля в HasFieldобязательном ReifiedGetter Person vи rобязательном порядке Person.
• Потому rчто Person, тип источника HasFieldдолжен быть Glass Person. Теперь мы можем разрешить тривиальный Glassyэкземпляр для the.
• Ключ kв HasFieldзадается как тип литерала: Symbol name.
• Мы проверяем предварительные условия экземпляра. Мы знаем , kи r, и они совместно определяют vиз-за HasFieldфункциональной зависимости. Экземпляр существует (автоматически генерируется для типов записей), и теперь мы знаем, что vэто так String. Мы успешно отсеяли все типы.