Haskell Overlapping/Inkohärente Instanzen

Question

Ich weiß, das ist Code ist ein bisschen albern, aber kann jemand erklären, warum diese isList [42]True zurückgibt, während isList2 [42] Drucke False, und wie dies zu verhindern? Ich würde gerne einige der obskureren GHC-Typ-Erweiterungen besser verstehen, und ich dachte, dies wäre ein interessantes Beispiel, um es herauszufinden.

{-# LANGUAGE FlexibleInstances #-} 
{-# LANGUAGE OverlappingInstances #-} 
{-# LANGUAGE IncoherentInstances #-} 

class IsList a where 
    isList :: a -> Bool 

instance IsList a where 
    isList x = False 

instance IsList [a] where 
    isList x = True 

isList2 = isList 

main = 
    print (isList 42) >> 
    print (isList2 42) >> 
    print (isList [42]) >> 
    print (isList2 [42]) 

Answer 1

Es ist wirklich ziemlich einfach. Lassen Sie uns GHCi fragen, was die Art der isList2 ist:

∀x. x ⊢ :t isList2 
isList2 :: a -> Bool 

Dies ist nicht die [a] Instanz überein (obwohl es könnte, über Vereinigung), aber es passen die a Instanz sofort. Daher wählt die GHC a Beispiel isList2 so kehrt False.

Dieses Verhalten ist genau das, was IncoherentInstances Mittel. Eigentlich ist das eine schöne Demonstration davon.

---

Vergnügt, wenn Sie einfach IncoherentInstances deaktivieren, erhalten wir genau die entgegengesetzte Wirkung, und GHCi sagt jetzt das:

∀x. x ⊢ :t isList2 
isList2 :: [Integer] -> Bool 

Dies geschieht, weil isList2 ist ein Top-Level-Bindung nicht mit der Funktion Syntax definiert und somit der gefürchteten Monomorphie Restriktion unterliegen. Es wird also auf die Instanz spezialisiert, mit der es tatsächlich verwendet wird.

Hinzufügen NoMonomorphismRestriction sowie das Deaktivieren IncoherentInstances, bekommen wir diese statt:

∀x. x ⊢ :t isList2 
isList2 :: IsList a => a -> Bool 
∀x. x ⊢ isList2 'a' 
False 
∀x. x ⊢ isList2 "a" 
True 
∀x. x ⊢ isList2 undefined 

<interactive>:19:1: 
    Overlapping instances for IsList a0 arising from a use of `isList2' 

, das das erwartete überlappende Verhalten ist, mit der Instanz gewählt basierend auf der Verwendung und Beschwerden, wenn die Wahl nicht eindeutig ist.

In Bezug auf die Bearbeitung der Frage glaube ich nicht, dass das gewünschte Ergebnis ohne Typ Anmerkungen möglich ist.

Die erste Möglichkeit besteht darin, isList2 eine Typ-Signatur zu geben, die verhindert, dass IncoherentInstances eine Instanz zu früh auswählt.

isList2 :: (IsList a) => a -> Bool 
isList2 = isList 

Sie werden wahrscheinlich das gleiche tun müssen anderswo isList erwähnt wird (wenn auch indirekt) ohne auf ein Argument angewendet wird.

Die zweite Option ist die Zahlenliterale und deaktivieren IncoherentInstances eindeutig zu machen.

main = 
    print (isList (42 :: Integer)) >> 
    print (isList2 (42 :: Integer)) >> 
    print (isList [42]) >> 
    print (isList2 [42]) 

In diesem Fall gibt es genug Informationen, eine sehr spezifische Instanz zu holen, so OverlappingInstances seine Sache tut.

Answer 2

Die folgende code funktioniert der Trick ohne IncoherentInstances erfordert:

{-# LANGUAGE FlexibleInstances #-} 
{-# LANGUAGE OverlappingInstances #-} 

class IsList a where 
    isList :: a -> Bool 

instance IsList a where 
    isList x = False 

instance IsList [a] where 
    isList x = True 

isList2 :: (IsList a) => a -> Bool 
isList2 = isList 

main = do 
    print (isList (42 :: Int)) 
    print (isList [42 :: Int]) 
    print (isList2 (42 :: Int)) 
    print (isList2 [42 :: Int]) 

ich nicht IncoherentInstances verwenden würde empfehlen, es scheint eine Menge Ärger zu verursachen, wie Sie leise verschiedene Überlastungen je nach Kontext leicht ganz anrufen .