haskell - message d'erreur de type ambigu de type ambigu pour le code dans l'instruction "where" avec l'extension TypeFamilies

Question

Est-ce que quelqu'un sait pourquoi ce code a échoué?

{-# LANGUAGE NoMonomorphismRestriction, 
      TypeFamilies #-} 

module Test where 

asExprTyp :: Expr γ => 
    γ α 
    -> α 
    -> γ α 
asExprTyp x _ = x 

int = undefined :: Integer 

class Expr γ where 
    a :: γ α 

-- this works fine 
b = a `asExprTyp` int 

-- this fails 
mcode = do 
    return() 
    where b = a `asExprTyp` int 

L'erreur est la suivante,

Test.hs:23:15: 
    Ambiguous type variable `γ0' in the constraint: 
    (Expr γ0) arising from a use of `a' 
    Probable fix: add a type signature that fixes these type variable(s) 
    In the first argument of `asExprTyp', namely `a' 
    In the expression: a `asExprTyp` int 
    In an equation for `b': b = a `asExprTyp` int 
Failed, modules loaded: none. 

Answer 1

Je ne vois pas ce que ghc se plaint non plus. Je pensais que c'était parce qu'il essayait de donner à la liaison locale un type monomorphe, mais l'ajout de NoMonoLocalBinds au langage pragma n'a rien changé.

Cependant, le code est compilé tel quel avec un HEAD récent (7.3.20111026), ainsi que le fait qu'il compile sans que TypeFamilies soit activé, ce qui supporte l'hypothèse de bug.

Si c'est un vrai problème, vous devez le résoudre: l'ajout de signatures de type rend ghc heureux.

Answer 2

D'accord, cela est un peu au-dessus de ma tête depuis que je ne l'ai jamais utilisé les familles de type à Haskell. Cependant, votre exemple n'utilise pas non plus de familles de types, alors j'ai pensé que je verrais ce qui se passe lorsque je supprime l'extension de langue TypeFamilies du pragma LANGUAGE. Il s'avère: il se compile bien alors! :)

Donc ça pourrait très bien être un bug GHC.

Cela dit, je fourré à un peu et remarqué que le suivant compile joyeusement avec TypeFamilies permis:

mcode = do 
      b 
      return() 
     where b = a `asExprTyp` int 

Ceci est probablement absurde, puisque son type inférée est mcode :: (Expr m, Monad m) => m(), plutôt que mcode :: Monad m => m(), mais mon point est que GHC semble heureux seulement quand le type de a est lié d'une certaine manière au type mcode.

Je ne sais pas si cela est utile, mais il a certainement piqué ma curiosité!