Quelle est la différence entre 'err @ (Left _)' et 'Left err'

Question

J'essaie les codes de < Real World Haskell >.

sur la version 6.10.4 GHC:

data ParseState = ParseState { 
    string :: String 
} deriving (Show) 

newtype Parse a = Parse { 
    runParse :: ParseState -> Either String (a, ParseState) 
} 

parse :: Parse a -> String -> Either String a 
parse parser initState = 
    case runParse parser (ParseState initState) of 
    Left err   -> Left err 
    Right (result, _) -> Right result 

Tout allait bien jusqu'à ce que je l'ai changé 'err gauche' à 'err @ (gauche _)':

-- err@(Left _)  -> err 
{- 
- Occurs check: cannot construct the infinite type: 
- a = (a, ParseState) 
- When generalising the type(s) for `parse' 
-} 

Toutes les idées?

Answer 1

C'est subtil. Le case scrute une valeur de type Either String (a, ParseState), donc quand vous nommez le modèle dans

err@(Left _) -> err 

err a ce même type. Toutefois, le type de retour de la fonction indique qu'il doit être Either String a, ce qui ne correspond pas au type de Either String (a, ParseState). En regardant le type de Left:

Left :: x -> Either x y 

Lorsque vous utilisez Left dans la droite dans

Left err -> Left err 

Vous donnez une chance de choisir un y différent, à savoir a au lieu de (a, ParseState).

Ainsi, même si les valeurs sont les mêmes, les types ne sont pas, et ils ne peuvent pas être remplacés.

Par ailleurs, il y a quelques fonctions très pratiques pour votre cas Control.Arrow (spécialisée à (->) pour simplifier):

left :: (a -> a') -> Either a b -> Either a' b 
right :: (b -> b') -> Either a b -> Either a b' 
(+++) :: (a -> a') -> (b -> b') -> Either a b -> Either a' b' 

dont la sémantique sont fixées par les théorèmes libres (lire: ils ont seulement un mise en œuvre raisonnable, de sorte qu'ils font ce que vous attendez de leurs types). Donc, vous pouvez écrire votre code comme:

parse parser = right fst . runParse parser . ParseState