Невидимая подпись типа в Haskell

Question

Я хочу использовать двусмысленный тип a в функции следующим образом, но он терпит неудачу.

foo :: (Read a, Show a) => IO() 
foo = print =<< (readLn :: IO a) 

Целью является получение разных выходов относительно заданной сигнатуры типа при фактическом вызове.

>>> foo :: Double => IO() 
34 -- user input 
34.0 -- output 

>>> foo :: Int => IO() 
34 -- user input 
34 -- output 

Как я могу управлять этим?

Answer 1

Простейшим путь - показать вашу переменную типа. Например, используя довольно новый GHC:

{-# LANGUAGE ScopedTypeVariables #-} 
foo :: forall proxy a. (Read a, Show a) => proxy a -> IO() 
foo _ = print (read "34" :: a) 

Тогда в GHCI:

Data.Proxy *Main> foo (Proxy :: Proxy Double) 
34.0 
Data.Proxy *Main> foo (Proxy :: Proxy Int) 
34 

Или, более экзотическое использование, опираясь на более неявное поведении Haskell:

*Main> foo [0.0] 
34.0 
*Main> foo [0] 
34 

Answer 2

Ни foo :: Double => IO(), ни foo :: Int => IO() не являются действительными сигнатурами, поскольку Double и Int не являются ограничениями.

Однако, вы можете легко сделать функцию полиморфные в тип возвращаемого значения и записать его следующим образом:

foo :: (Read a, Show a) => IO a 
foo = let x = read "34" in print x >> return x 

Таким образом, вы можете использовать foo :: IO Double или foo :: IO Integer:

ghci> foo :: IO Double 
34.0 -- print 
34.0 -- result, you would discard it 
ghci> foo :: IO Integer 
34 
34