haskell - ejemplo - ¿Cómo puedo determinar por qué ghc está buscando una instancia de clase de tipo particular?

como definir tipos en haskell

Question

Cuando las instancias de clase de tipo condicional son profundas, puede ser difícil entender por qué ghc se queja de una instancia de clase de tipo faltante. Por ejemplo:

class MyClass1 c
class MyClass2 c
class MyClass3 c

data MyType1 a
data MyType2 a

instance MyClass1 a => MyClass2 (MyType1 a)
instance MyClass2 a => MyClass3 (MyType2 a)

foo :: (MyClass3 c) => c
foo = undefined

bar :: MyType2 (MyType1 Int)
bar = foo

GHC da el siguiente error:

Example.hs:149:7-9: error:
    • No instance for (MyClass1 Int) arising from a use of ‘foo’
    • In the expression: foo
      In an equation for ‘bar’: bar = foo
    |
149 | bar = foo
    |       ^^^

Suponiendo que solo escribí las definiciones para foo y bar , y todo lo demás era un código importado que no escribí, puedo estar muy confundido en cuanto a por qué ghc está intentando encontrar una instancia de MyClass1 para Int . Esta podría ser la primera vez que oigo hablar de la clase MyClass1 , si hasta ahora me he basado en instancias importadas. Sería bueno si ghc pudiera darme un "seguimiento de pila" de la cadena de instancia de clase de tipo, por ejemplo

Sought (MyClass2 (MyType1 Int)) to satisfy (MyClass3 (MyType2 (MyType1 Int))) from conditional type class instance OtherModule.hs:37:1-18
Sought (MyClass1 Int) to satisfy (MyClass2 (MyType1 Int)) from conditional type class instance OtherModule.hs:36:1-18

¿Tiene ghc una opción de línea de comando para esto? Si no, ¿cómo depuro esto?

Tenga en cuenta que mi problema real es mucho más complicado que este simple ejemplo. p.ej

Search.hs:110:31-36: error:
    • Could not deduce (Ord
                          (Vars (DedupingMap (Rep (Index gc)) (IndexedProblem ac))))
        arising from a use of ‘search’
      from the context: (PP gc (IndexedProblem ac),
                         Show (Vars (DedupingMap (Rep (Index gc)) (IndexedProblem ac))),
                         Foldable f, MonadNotify m)
        bound by the type signature for:
                   searchIndexedReplicaProblem :: forall gc ac (f :: * -> *) (m :: *
                                                                                   -> *).
                                                  (PP gc (IndexedProblem ac),
                                                   Show
                                                     (Vars
                                                        (DedupingMap
                                                           (Rep (Index gc)) (IndexedProblem ac))),
                                                   Foldable f, MonadNotify m) =>
                                                  f (Index
                                                       (Clzs
                                                          (PartitionedProblem
                                                             gc (IndexedProblem ac))))
                                                  -> m (Maybe
                                                          (Vars
                                                             (PartitionedProblem
                                                                gc (IndexedProblem ac))))
        at Search.hs:(103,1)-(109,131)
    • In the expression: search
      In an equation for ‘searchIndexedReplicaProblem’:
          searchIndexedReplicaProblem = search
    |
110 | searchIndexedReplicaProblem = search
    |                               ^^^^^^

Existen cinco condiciones de cobertura para el PP, y estoy usando familias de tipos e instancias no definibles, por lo que no es muy obvio por qué ghc me está dando su error. ¿Qué herramientas puedo usar para localizar el problema?

Answer 1

Puede probar la -ddump-cs-trace , aunque su objetivo es ayudar a los desarrolladores de GHC cuando la depuración restringe el código de resolución de restricciones, pero también podría ser útil para usted. Aquí está la salida para su ejemplo:

Step 1[l:2,d:0] Kept as inert:
    [G] $dMyClass3_a1rt {0}:: MyClass3 c_a1rs[sk:2]
Step 2[l:2,d:0] Dict equal (keep):
    [WD] $dMyClass3_a1rv {0}:: MyClass3 c_a1rs[sk:2]
Constraint solver steps = 2
Step 1[l:1,d:0] Top react: Dict/Top (solved wanted):
    [WD] $dMyClass3_a2uc {0}:: MyClass3 (MyType2 (MyType1 Int))
Step 2[l:1,d:1] Top react: Dict/Top (solved wanted):
    [WD] $dMyClass2_a2up {1}:: MyClass2 (MyType1 Int)
Step 3[l:1,d:2] Kept as inert:
    [WD] $dMyClass1_a2uq {2}:: MyClass1 Int
Step 4[l:2,d:0] Kept as inert:
    [G] $dMyClass3_a1rB {0}:: MyClass3 c_a1rz[sk:2]
Step 5[l:2,d:0] Wanted CallStack IP:
    [WD] $dIP_a2u8 {0}:: ?callStack::GHC.Stack.Types.CallStack
Step 6[l:2,d:0] Kept as inert:
    [WD] $dIP_a2uA {0}:: ?callStack::GHC.Stack.Types.CallStack
Step 7[l:2,d:0] Kept as inert:
    [G] $dMyClass2_a2uh {0}:: MyClass2 a_a2ug[ssk:2]
Step 8[l:2,d:0] Kept as inert:
    [G] $dMyClass1_a2ul {0}:: MyClass1 a_a2uk[ssk:2]
Constraint solver steps = 8

No es fácil extraer información útil de este volcado, pero AFAIK es la única opción disponible en este momento. Pocas entradas relacionadas: 13443 , 15044

AÑADIDO: Intentaré explicar un poco lo que significa el volcado. En realidad no estoy familiarizado con los aspectos internos de GHC, por lo que es solo mi comprensión (probablemente incorrecta).

El bit relevante es el siguiente:

Step 1[l:1,d:0] Top react: Dict/Top (solved wanted):
    [WD] $dMyClass3_a2uc {0}:: MyClass3 (MyType2 (MyType1 Int))
Step 2[l:1,d:1] Top react: Dict/Top (solved wanted):
    [WD] $dMyClass2_a2up {1}:: MyClass2 (MyType1 Int)
Step 3[l:1,d:2] Kept as inert:
    [WD] $dMyClass1_a2uq {2}:: MyClass1 Int

Aquí d significa "profundidad", WD es una restricción "deseada derivada". Así que tenemos algo así como un rastro de la pila de restricciones deseadas: inicialmente queríamos MyClass3 (MyType2 (MyType1 Int)) , luego encontramos la instancia de MyClass3 para MyType2 , y ahora queremos que MyClass2 (MyType1 Int) satisfaga. Luego encontramos la instancia de MyType1 para MyType1 , ahora queremos que MyClass1 Int satisfaga. Lo sé, la explicación es vaga, pero eso es todo lo que tengo para ti, lo siento.