Valutazioni pigre delle strutture dati

Question

Sto leggendo su valutazioni pigre in haskell e ho una domanda. Per esempio abbiamo seguenti calcoli:

Prelude> let x = 1 + 1 :: Int 
Prelude> let y = (x,x) 

E dopo aver ottenuto il valore di x:

Prelude> :sprint x 
x = _ 

E 'non valutata. Ok, ora veniamo valore di y:

Prelude> :sprint y 
y = (_,_) 

E 'non valutata troppo, perché y dipende x and it's unevaluated. Ora proviamo lo stesso esempio, ma senza ::Int:

Prelude> let x = 1 + 1 
Prelude> let y = (x, x) 
Prelude> :sprint y 
y = _ 

Perché y valore è _ invece (_, _) quando stiamo cercando senza ::Int?

vedo che hanno diversi tipi:

Prelude> let x = 1 + 1 
Prelude> :t x 
x :: Num a => a 
Prelude> let x = 1 + 1 :: Int 
Prelude> :t x 
x :: Int 

Ma perché i valori di y dipende da esso?

Grazie.

Answer 1

Quello che sta accadendo è che quando hai specificato x di avere il tipo di Num a => a, il compilatore non può assolutamente sapere quale istanza di Num da utilizzare durante l'esecuzione 1 + 1. Quello che invece usa è l'impostazione predefinita. GHC definisce i tipi predefiniti per determinati tipi di caratteri, in modo tale che quando non è possibile determinare quale tipo concreto di utilizzo può dare risultati significativi senza generare errori. Quindi, quando si vede

> let x :: Num a => a 
|  x = 1 + 1 
> x 
2 
> :sprint x 
x = _ 

Questo perché GHCi sceglie Integer come il suo tipo di default per Num, ma quando si esegue questa operazione non memorizza il risultato in x s' posizione di memoria, dal momento che non v'è un modo per sapere se questa è anche la risposta corretta. Questo è il motivo per cui vedi x = _ da :sprint, non ha effettivamente valutato x :: Num a => a, è valutato x :: Integer. È anche possibile confusione con questa impostazione predefinita se stessi:

> newtype MyInt = MyInt Int deriving (Eq) 
> 
> instance Show MyInt where 
|  show (MyInt i) = show i 
> instance Num MyInt where 
|  (MyInt x) + (MyInt y) = MyInt (x - y) 
|  fromInteger = MyInt . fromInteger 
> 
> default (MyInt) 
> x 
0 

Così ora abbiamo detto che 1 + 1 = 0! Tenete presente che probabilmente non userete mai per questa funzionalità di GHC, ma è utile sapere.