Simplify Monadic Type Signature in Haskell

Question

I'm still new to Haskell and am having trouble to find the correct type signature for a function.

I have this working, fairly straightforward function using http-conduit and authenticate-oauth which is side-effecting, so I don't care too much about the return value:

executeOAuthRequest oauth cred request =
    withManager $ \manager -> do
        signed <- signOAuth oauth cred request
        http signed manager

I would like to specify the correct type signature, but the output from GHCi looks rather terrifying to me:

executeOAuthRequest
  :: (monad-control-0.3.2.3:Control.Monad.Trans.Control.MonadBaseControl
        IO m,
      Control.Monad.Trans.Resource.Internal.MonadThrow m,
      Control.Monad.Trans.Resource.Internal.MonadUnsafeIO m,
      Control.Monad.IO.Class.MonadIO m) =>
     OAuth
     -> Credential
     -> Request
     -> m (Response (ResumableSource (ResourceT m) ByteString))

The first three arguments (OAuth, Credential, Request) make sense to me, but I don't understand the long precondition for m and wonder if it's necessary to specify the full return value as GHCi suggests.

Rather than only providing the correct signature, I'd like to understand what the process behind finding and reducing the correct one looks like.

Note that IO implements all those constraints, so if you only need to use IO, you can just drop the constraint and specialize m to IO like this: OAuth -> Credential -> Request -> IO (Respond (ResumableSource (ResourceT IO) ByteString)) — Gabriella Gonzalez
@GabrielGonzalez Thank you! Is this because IO is * -> * or is there another property because of which it satisfies all constraints? — passy
@passy no. * -> * is a kind. It only means that IO is a type constructor (and IO a is a type for any type a). IO statisfies all constraints because the typeclasses instances are declared. as an example, IO has a MonadIO instance. The more complex type signature is useful because there are other monads which acts like IO, and which can be used instead. — Simon Bergot
@passy The idea is that those constraints make the type more flexible so that your function can be used with monads other than IO. However, if you don't need that extra flexibility you can simplify the type by choosing a specific monad that implements those constraints. — Gabriella Gonzalez

jberryman jberryman · Accepted Answer · 2014-04-21T17:41:50

GHCi is giving you the most polymorphic signature, reading "any type m which is an instance of the classes MonadThrow from the Monad.Trans.Resource.Internal module, MonadIO, etc". The type-checker is sort of taking the union of all the constraints introduced by the types of those polymorphic functions you're composing in executeOAuthRequest.

Here's a simple example:

Prelude> let f n = n + 1
Prelude> :t f  -- GHC infers the polymorphic signature constrained to `Num`:
f :: Num a => a -> a
Prelude> let f :: Int -> Int ; f n = n + 1
Prelude> :t f
f :: Int -> Int

It might be that the only type which satisfies all those constraints in your function is IO, or there might be several. The usual way to check is by reading the haddocks, or doing e.g.

Prelude> :info IO
...
instance Monad IO -- Defined in ‘GHC.Base’
instance Functor IO -- Defined in ‘GHC.Base’
Prelude> :info Monad
...
instance Monad [] -- Defined in ‘GHC.Base’
instance Monad IO -- Defined in ‘GHC.Base’
instance Monad ((->) r) -- Defined in ‘GHC.Base’

So if you only use your function in IO you can give it the type:

executeOAuthRequest
  :: OAuth
     -> Credential
     -> Request
     -> IO (Response (ResumableSource (ResourceT m) ByteString))

or you could keep the polymorphic signature, if for instance you're exporting this function in a library and think your users might want to use it in a different monad (maybe even by defining their own new type and making it an instance of MonadIO, MonadThrow, etc)

Simplify Monadic Type Signature in Haskell

1 Answers