Trasformare le funzioni di tipo `a -> b` in quelle di tipo` String -> String` in Haskell

Question

La mia intenzione è semplice. Voglio racchiudere le funzioni di tipo a -> b in String -> String (in modo che un gruppo di funzioni eterogenee possa essere inserito in una lista). Così scrivo:

wrap :: (Read a, Show b) => (a -> b) -> (String -> String) 
wrap f = \s -> show $ f (read s :: a) 

Tuttavia, ghc lamentele:

Could not deduce (Read a1) arising from a use of `read' 
from the context (Read a, Show b) 
    bound by the type signature for 
      wrap :: (Read a, Show b) => (a -> b) -> String -> String 

Voglio sapere il motivo per cui il mio pezzo di codice non funzionerà e che tipo di hack è necessario per raggiungere il mio obiettivo?

Grazie.

Answer 1

Il codice non funzionerà perché Haskell non ri-uso o tipo portata variabili; il a in wrap :: (Read a, Show b) => (a -> b) -> (String -> String) è completamente diverso da read s :: a (e sono entrambi quantificati universalmente). Questa è la fonte dello a1 nel messaggio di errore; GHC è alfa-conversione del programma in

wrap :: (Read a, Show b) => (a -> b) -> (String -> String) 
wrap f = \s -> show $ f (read s :: a1) 

Tuttavia, tipo di argomento f s' è fissato all'interno wrap, così semplicemente rimuovendo il tipo di annotazione funziona bene. La funzione diventa

wrap :: (Read a, Show b) => (a -> b) -> (String -> String) 
wrap f = \s -> show $ f (read s) 
    -- Or wrap f = show . f . read 

E lo si può utilizzare:

ghci> map ($ "42") [wrap (+ (7 :: Integer)), wrap (* (2.0 :: Double))] 
["49","84.0"] 

Si noti che questo significa che read s ha un tipo non è possibile scrivere. In Haskell 2010 (o 98), l'unico modo per aggirare questo è usare una funzione come asTypeOf :: a -> a -> a; asTypeOf è solo const, ma grazie alla sua firma del tipo, vincola il suo argomento first, ritornato, dello stesso tipo del suo secondo. Quindi, ovviamente, dovresti evocare una variabile di tipo a. Di seguito funzionerebbe per questo:

wrap :: (Read a, Show b) => (a -> b) -> (String -> String) 
wrap f = \s -> show $ f (read s `asTypeOf` fInput) 
    where fInput = undefined 
     fOutput = f fInput -- I still can't give this a type signature 

In GHC, per evitare questo, è possibile attivare the ScopedTypeVariables extension; con quello attivo, se si qualificano esplicitamente tutte le variabili di tipo con un forall, verranno esaminate come i nomi a livello di valore. Allora il vostro codice sarebbe diventato

{-# LANGUAGE ScopedTypeVariables #-} 
wrap :: forall a b. (Read a, Show b) => (a -> b) -> (String -> String) 
wrap f = \s -> show $ f (read s :: a) 

Ma ricordate, non è necessario alcun tipo annotazioni a tutti per questo semplice esempio.

Answer 2

Per specificare il tipo di read s esplicitamente, avrete bisogno di qualcosa di simile a ScopedTypeVariables:

{-# LANGUAGE ScopedTypeVariables #-} 
... 
wrap :: forall a b. (Read a, Show b) => (a -> b) -> (String -> String) 
wrap f = \s -> show $ f (read s :: a) 

altrimenti il ​​:: a annotazioni all'interno della funzione si riferisce ad un tipo diverso dal a nella firma tipo (implicitamente significa :: forall a. a). Ma nota che si può anche semplicemente cadere il tipo di annotazione del tutto:

wrap :: (Read a, Show b) => (a -> b) -> (String -> String) 
wrap f = \s -> show $ f (read s) 

Dal momento che il tipo di read s può dedurre. Ciò consente inoltre di semplificare l'organismo a

wrap f = show . f . read