Perché il contesto non viene preso in considerazione quando si seleziona l'istanza di classe tipo in Haskell?

Question

Capisco che quando avendo

instance (Foo a) => Bar a 
instance (Xyy a) => Bar a 

GHC non prende in considerazione i contesti e le istanze sono riportati come duplicato.

Ciò che è controintuitivo, che (credo) dopo aver selezionato un'istanza, deve ancora verificare se il contesto corrisponde, e in caso contrario, scartare l'istanza. Quindi, perché non invertire l'ordine e scartare le istanze con contesti non corrispondenti e procedere con il set rimanente.

Sarebbe intrattabile in qualche modo? Vedo come potrebbe causare una maggiore risoluzione dei vincoli in anticipo, ma proprio come c'è UndecidableInstances/IncoherentInstances, non potrebbe esserci un ConsiderInstanceContexts quando "So cosa sto facendo"?

Answer 1

Questo non risponde alla domanda sul perché questo è il caso. Si noti, tuttavia, che è sempre possibile definire un involucro newtype per disambiguare tra le due istanze:

newtype FooWrapper a = FooWrapper a 
newtype XyyWrapper a = XyyWrapper a 

instance (Foo a) => Bar (FooWrapper a) 
instance (Xyy a) => Bar (XyyWrapper a) 

Questo ha il vantaggio che facendo passare attorno o un FooWrapper o un XyyWrapper è possibile controllare in modo esplicito quale delle due istanze si 'Mi piacerebbe usare se il tuo a soddisfa entrambi.

Answer 2

Le lezioni sono un po 'strane. L'idea originale (che funziona ancora abbastanza) è una sorta di zucchero sintattico attorno a ciò che altrimenti sarebbero le dichiarazioni data. Ad esempio, puoi immaginare:

data Num a = Num {plus :: a -> a -> a, ... , fromInt :: Integer -> a} 
numInteger :: Num Integer 
numInteger = Num (+) ... id 

quindi puoi scrivere funzioni che hanno ad es. tipo:

test :: Num x -> x -> x -> x -> x 
test lib a b c = a + b * (abs (c + b)) 
    where (+) = plus lib 
      (*) = times lib 
      abs = absoluteValue lib 

Quindi l'idea è "stiamo per derivare automaticamente tutto questo codice di libreria." La domanda è: come troviamo la biblioteca che vogliamo? E 'facile se abbiamo una biblioteca di tipo Num Int, ma come facciamo a estenderlo a "istanze vincolati" sulla base di funzioni di tipo:

fooLib :: Foo x -> Bar x 
xyyLib :: Xyy x -> Bar x 

La presente soluzione in Haskell è quello di fare un tipo reticolo corrispondere ai tipi di output di tali funzioni e propagare gli input alla dichiarazione risultante. Ma quando ci sono due uscite dello stesso tipo, avremmo bisogno di un combinatore che si fonde questi in:

eitherLib :: Either (Foo x) (Xyy x) -> Bar x 

e fondamentalmente il problema è che non c'è un buon vincolo-combinatore di questo tipo al momento. Questa è la tua obiezione.

Bene, questo è vero, ma ci sono modi per ottenere qualcosa di moralmente simile nella pratica. Supponiamo di definire alcune funzioni con i tipi:

data F 
data X 
foobar'lib :: Foo x -> Bar' x F 
xyybar'lib :: Xyy x -> Bar' x X 
bar'barlib :: Bar' x y -> Bar x 

Chiaramente il y è una sorta di "tipo fantasma" threaded attraverso tutto questo, ma rimane potente perché, dato che vogliamo un Bar x saremo propagare la necessità di un Bar' x y e data la necessità per il Bar' x y genereremo uno Bar' x X o un Bar' x y. Quindi con i tipi di fantasmi e le classi di tipi a più parametri, otteniamo il risultato che vogliamo.

Maggiori informazioni: https://www.haskell.org/haskellwiki/GHC/AdvancedOverlap