How do I specialise with an explicit type application?

Question

With GHC 8.0, I can write an ambiguous function that's overloaded over some type not mentioned in the main part of its type signature, and then call it using an explicit type application:

{-# LANGUAGE ScopedTypeVariables, RankNTypes,
             AllowAmbiguousTypes, TypeApplications, TypeFamilies #-}

showRead :: forall t . (Read t, Show t) => String -> String
showRead x = show (read x :: t)

showReadInt = showRead @Int

I'd like to use a SPECIALIZE pragma to force a specialisation of showRead for Int (my real code has the actual call site in a different module). However, the normal SPECIALIZE syntax is based on writing the main part of the type signature, e.g.:

{-# SPECIALIZE showRead :: String -> String #-}

and in this case that doesn't allow me to specify what t should be, and predictably gives an error about it being ambiguous.

I tried using an equality constraint:

{-# SPECIALISE showRead :: forall t . (Read t, Show t, t ~ Int) => String -> String #-}

but that just gave the error:

• Could not deduce (Read t0) a SPECIALISE pragma for ‘showRead’
  from the context: (Read t, Show t, t ~ Int)
    bound by the type signature for:
               showRead :: (Read t, Show t, t ~ Int) => String -> String
    at foo.hs:4:1-76
  The type variable ‘t0’ is ambiguous

Is there any way I can do this? Of course I could just use a Proxy, but it seems a shame not to use the shiny new way instead.

Answer 1

This isn't supported in GHC 8.0, but is now the subject of a proposal to support it in future GHCs.