Perché è possibile omettere la funzione di costruzione quando si fa riferimento a tipi di numeri avvolti di nuovo tipo?

Question

A pagina 321 di Real World Haskell

Ci sono questi codici,

...

{-# LANGUAGE GeneralizedNewtypeDeriving #-} 
newtype AInt = A { unA::Int } 
    deriving (Show, Eq, Num) 

instance Monoid AInt where 
    mempty = 0 

La mia confusione è per questo che è

mempty = 0 

ma non

mempty = A 0 

?

---

Ho anche notato che sia

ghci> 0 :: AInt 

e

ghci> A 0 :: AInt 

mi danno la stessa risposta

A { unA = 0 } 

Qualcuno per favore mi dica qual è la differenza tra la tesi Due?

Answer 1

Il trucco qui è con l'estensione GeneralizedNewtypeDeriving. In particolare, questo ci consente di derivare qualsiasi classe per un valore di newtype a condizione che il tipo sottostante sia un'istanza. Tutto ciò che fa è copiare l'istanza dal vecchio tipo al nuovo tipo.

In questo caso particolare, AInt deriva Num. Ciò significa che AInt è un'istanza di Num che utilizza lo stesso codice di Int (con tutto ciò che è racchiuso nei costruttori A a seconda dei casi). Ciò include la funzione fromInteger di.

La funzione fromInteger è definita in termini di Int s' fromInteger, cercando qualcosa di simile:

fromInteger i = A (fromInteger i) 

Dal 0 è polimorfico - ha il tipo 0 :: Num a => a --è è una costante valida per qualsiasi digitare Num. Grazie al newtype derivante, questo include AInt, utilizzando la funzione fromInteger sopra. Ciò significa che non vi è alcuna differenza tra 0 :: AInt e A 0 :: AInt.

Answer 2

I valori letterali numerici come 0 sono sovraccarichi e hanno il tipo 0 :: Num a => a, il che significa che possono essere di qualsiasi tipo per cui esiste un'istanza Num, a seconda del contesto. Ciò avviene tramite la funzione fromInteger nella classe di tipo Num, pertanto quando si digita 0 viene trattato come se fosse stato scritto fromInteger 0.

Utilizzando GeneralizedNewtypeDeriving, GHC ha (in modo efficace) scritto un'istanza Num per la classe cercando qualcosa di simile:

instance Num AInt where 
    fromInteger n = A (fromInteger n) 
    ... 

Quindi, quando si scrive 0 :: AInt, questo si espande a fromInteger 0 :: AInt che è (dal definizione sopra) uguale a A (fromInteger 0), che è lo stesso come se avessi scritto A 0.

_{GeneralizedNewtypeDeriving in realtà non scrive una nuova prospettiva. Esegue semplicemente i cast necessari per utilizzare quello esistente.}