Perché i valori polimorfici non vengono dedotti in Haskell?

Question

letterali numerici hanno un tipo polimorfico:

*Main> :t 3 
3 :: (Num t) => t 

Ma se mi legano una variabile a tale letterale, il polimorfismo si perde:

x = 3 
... 
*Main> :t x 
x :: Integer 

Se io definisco una funzione, d'altra parte, è naturalmente polimorfa:

f x = 3 
... 
*Main> :t f 
f :: (Num t1) => t -> t1 

potrei fornire una firma tipo per garantire la x rimane polimorfa:

x :: Num a => a 
x = 3 
... 
*Main> :t x 
x :: (Num a) => a 

Ma perché è necessario? Perché il tipo polimorfico non è desunto?

Answer 1

È il monomorphism restriction che dice che tutti i valori, che sono definiti senza parametri e non hanno un'annotazione di tipo esplicita, dovrebbero avere un tipo monomorfico. Questa limitazione può essere disabilitata in ghc e ghci usando -XNoMonomorphismRestriction.

La ragione per la restrizione è che senza questa restrizione long_calculation 42 sarebbero stati valutati due volte, mentre la maggior parte delle persone probabilmente aspetta/vuole che sia valutata solo una volta:

longCalculation :: Num a => a -> a 
longCalculation = ... 

x = longCalculation 42 

main = print $ x + x 

Answer 2

Per espandere sulla risposta di sepp2k un po ': se si tenta di compilare il seguente (o caricarlo in GHCi), si ottiene un errore:

import Data.List (sort) 
f = head . sort 

questa è una violazione della restrizione monomorfismo perché abbiamo un vincolo di classe (introdotto da sort), ma non ex Argomenti impliciti: siamo (in qualche modo misteriosamente) a dire che abbiamo un nel vincolo Ord a.

Il vostro esempio (let x = 3) ha una variabile di tipo simile ambiguo, ma non dà lo stesso errore, perché è salvato da Haskell's "defaulting" rules:

Any monomorphic type variables that remain when type inference for an entire module is complete, are considered ambiguous, and are resolved to particular types using the defaulting rules (Section 4.3.4).

Vedi this answer per ulteriori informazioni sulle inadempienti regole-il il punto importante è che funzionano solo per determinate classi numeriche, quindi x = 3 va bene mentre non lo è lo standard f = sort.

Come nota a margine: se si preferisce che x = 3 finiscono per essere un Int invece di un Integer, e y = 3.0 essere un Rational invece di un Double, è possibile utilizzare una "dichiarazione di default" per ignorare l'impostazione predefinita inadempiente regole :

default (Int, Rational)