How do I refer to the same type variable in different type annotations?

Question

Say I have the following:

import Control.Monad.Random

foo :: IO Float
foo = fmap realToFrac getRandom

GHC rightly complains about not knowing the type of getRandom; I can fix this by doing

foo = fmap realToFrac (getRandom :: IO Double)

However, consider instead the situtation where I have:

foo :: (Functor m, MonadRandom m) => m Float
foo = fmap realToFrac getRandom

I can not do only

foo = fmap realToFrac (getRandom :: m Double)

I must repeat the MonadRandom constraint:

foo = fmap realToFrac (getRandom :: MonadRandom m => m Double)

With a high number of constraints, this would result in a lot of extra typing. I would rather not have to do that. I am aware that I could use ScopedTypeVariables:

{-# LANGUAGE ScopedTypeVariables #-}

import Control.Monad.Random

foo :: MonadRandom m => m Float
foo = do
    x :: Double <- getRandom
    return (realToFrac x)

but this is just as verbose, and additionally I wouldn't be able to apply it in all such situations.

I am also aware of the PartialTypeSignatures proposal. I think this might allow me to do:

foo = fmap realToFrac (getRandom :: _ Double)

but it's not entirely clear from my scan over its (long) description. Unfortunately, PartialTypeSignatures is not ready for primetime and as such has not yet been included in a released version of GHC.

I'm obviously welcome to other suggestions, but one solution to this problem I can think of would be some way to identify m with n in the following:

foo :: (Functor m, MonadRandom m) => m Float
foo = fmap realToFrac (getRandom :: n Double)

Is this kind of thing possible?

Answer 1

Your intuition was correct: ScopedTypeVariables is the right extension for the job:

{-# LANGUAGE ScopedTypeVariables #-}

import Control.Monad.Random

foo :: (Functor m, MonadRandom m) => m Float
foo = fmap realToFrac (getRandom :: m Double)