Guai di inferenza del tipo di GHC

Question

Domanda. C'è un modo per far funzionare questo codice senza una firma di tipo esplicita?

Codice. Innanzitutto, ho una classe alternativa allo MonadTrans alternativa molto più bella, ispirata allo Data.Newtype. Ecco come si presenta,

{-# LANGUAGE FlexibleContexts, TypeFamilies #-} 

module Alt.Control.Monad.Trans where 

import Control.Monad 

class (Monad , Monad (BaseMonad)) => MonadTrans (:: * -> *) where 
    type BaseMonad :: * -> * 
    lift :: (BaseMonad) α -> α 

Poi, ho una classe A con il metodo foo, e se alcuni di base monade M è un A, allora ogni monade trasformato T M è anche un A. Nel codice,

class A where 
    foo :: String -> () 

instance (A (BaseMonad), MonadTrans) => A where 
    foo n = lift $ foo n 

Tuttavia, se ora voglio creare un collegamento per foo con il suo primo argomento sostituito, quindi ho bisogno di una firma di tipo esplicito, o stack overflow contesto del compilatore.

minimize_call :: A => () 
minimize_call = foo "minimize" 

Possibili informazioni per aiutare l'inferenza. Diciamo che abbiamo un tipo associato B :: * -> *. Sto pensando che voglio dire al compilatore B soddisfa B t /= t, B (B t) /= B t, ecc. Cioè B è in qualche modo "monotono" - che inseguire tipi associati equivale a rimuovere i wrapper newtype, e dovrebbe sapere che non può rimuovere per sempre i wrapper newtype , quindi aggiungere il contesto A alla firma è necessario.

Answer 1

Sì, c'è un modo. Fornire un'istanza di messa a terra per A e aggiungere NoMonomorphismRestriction al pragma della lingua (oltre a quello richiesto anche FlexibleInstances e UndecidableInstances).

Tuttavia, la classe A non sarà utilizzabile. Non c'è modo per il compilatore di sapere che non ci sarà mai un'istanza MonadTrans con BaseMonad m = m. Pertanto non può selezionare un'istanza, mai, perché non può sapere se usare l'istanza da qui o un'altra.

{-# LANGUAGE FlexibleContexts, TypeFamilies, FlexibleInstances, UndecidableInstances, NoMonomorphismRestriction #-} 

module Trans (MonadTrans(..), A(..), minimize_call) where 

import Control.Monad 

class (Monad m, Monad (BaseMonad m)) => MonadTrans (m :: * -> *) where 
    type BaseMonad m :: * -> * 
    lift :: (BaseMonad m) α -> m α 

class A m where 
    foo :: String -> m() 


data Foo a = Bork 

instance Monad Foo where 
    return _ = Bork 
    _ >>= _ = Bork 

instance A Foo where 
    foo _ = Bork 


instance (A (BaseMonad m), MonadTrans m) => A m where 
    foo n = lift $ foo n 

-- minimize_call :: A m => m() 
minimize_call = foo "minimize" 

compila con ghc 6.12, 7.0, 7.2 e 7.4. Senza la firma, minimize_call deve ottenere un tipo monomorfico, a meno che il MR non sia disattivato. Questo non può funzionare comunque perché il vincolo A m non è predefinito. Quindi, il MR deve essere spento. Ma il type checker insegue ancora la coda cercando di dimostrare che il vincolo è soddisfacente. Con solo l'istanza di sollevamento, non può. Se fornisci un'ancora, può.

Ma fornire una firma del tipo è molto meglio.