¿Por qué recibo esta advertencia de GHCi?

Question

me estoy haciendo una curiosa advertencia cuando la coincidencia de patrones, pero sólo cuando está activado OverloadedStrings ...

$ ghci -Wall 
GHCi, version 6.12.1: http://www.haskell.org/ghc/ :? for help 
Loading package ghc-prim ... linking ... done. 
Loading package integer-gmp ... linking ... done. 
Loading package base ... linking ... done. 
Prelude> let f x = case (x :: [String]) of {[""] -> "root"; ["product", _] -> "product"; _ -> "unknown"} 
Prelude> :q 
Leaving GHCi. 
$ ghci -Wall -XOverloadedStrings 
GHCi, version 6.12.1: http://www.haskell.org/ghc/ :? for help 
Loading package ghc-prim ... linking ... done. 
Loading package integer-gmp ... linking ... done. 
Loading package base ... linking ... done. 
Prelude> let f x = case (x :: [String]) of {[""] -> "root"; ["product", _] -> "product"; _ -> "unknown"} 

<interactive>:1:10: 
    Warning: Pattern match(es) are overlapped 
      In a case alternative: [""] -> ... 
Prelude> let g x = case (x :: [String]) of {[] -> "root"; ["product", _] -> "product"; _ -> "unknown"} 
Prelude> let h x = case (x :: [String]) of {["oops"] -> "root"; ["product", _] -> "product"; _ -> "unknown"} 
Prelude> :q 
Leaving GHCi. 

No entiendo por qué me da la advertencia para f con OverloadedStrings, sobre todo porque no lo hago Obtiene la advertencia para f sin OverloadedStrings, y tampoco recibe la advertencia para g o h, que difieren de f solo en el primer patrón (que en todos los casos coincide solo con un valor particular).

Suponiendo que esto no es un error en GHC, ¿qué me estoy perdiendo?

Answer 1

Aquí está un poco más sencillo ejemplo que muestra el mismo problema en GHC 6.12.3:

f :: String -> Bool 
f "" = True 
f "a" = False 

g :: String -> Bool 
g "" = True 
g "aa" = False 

Solo g recibe la advertencia de superposición con -XOverloadedStrings. Creo que esto tiene que ser un error.

Answer 2

EDIT: Básicamente desea que este (después de la conversión de juego de vuelta de (IsString b) => b en [Char] pero se realiza la casación en tipos coherente):

f :: [String] -> String 
f = matchf 

matchf :: (Show b, IsString a, Eq a, IsString b) => [a] -> b 
matchf x = case x of [""] -> "root"; ["product", _] -> "product"; _ -> "unknown" 

De lo contrario GHC advierte sobre la correspondencia de "" :: String a "" :: (Data.String.IsString t) => t (literal). Sería interesante averiguar por qué, dado que literales "" valores predeterminados correctamente para cuerdas (probablemente un error?):

Prelude> show ("" :: (Data.String.IsString t) => t) 

<interactive>:1:0: 
    Warning: Defaulting the following constraint(s) to type `String' 

---

La cadena debe estar derivando la ecuación de coincidencia de patrones para trabajar con -XOverloadedStrings. String sigue siendo solo [Char] con -XOverloadedStrings pero los literales de cadena no lo son.

Otra manera de hacer esto sin que se dispare una advertencia:

test.hs:

import GHC.Exts(IsString(..)) 

newtype OString = OString String deriving (Eq, Show) 
instance IsString OString where fromString = OString 

f :: [OString] -> OString 
f x = case (x :: [OString]) of {[""] -> "root"; ["product", _] -> "product"; _ -> "unknown"} 

Run que:

$ ghci -Wall -XOverloadedStrings 
GHCi, version 6.12.1: http://www.haskell.org/ghc/ :? for help 
Loading package ghc-prim ... linking ... done. 
Loading package integer-gmp ... linking ... done. 
Loading package base ... linking ... done. 
Prelude> :l test.hs 
[1 of 1] Compiling Main    (test.hs, interpreted) 
Ok, modules loaded: Main. 
*Main> f [] 
OString "unknown" 
*Main> f [""] 
OString "root" 
*Main> f ["product"] 
OString "unknown" 
*Main> f ["product", "x"] 
OString "product" 

Fuente: http://www.haskell.org/ghc/docs/6.12.2/html/users_guide/type-class-extensions.html#overloaded-strings