Haskell cast higher kinded types - haskell

Question

This code is compiling:
trigger :: (Typeable n) => n () -> IO ()
trigger n = case (cast n) of
Just n' -> n'
Nothing -> error "n is not IO"
But if I add parenthesis it doesn't anymore:
-- not compiling
trigger' :: (forall n. (Typeable n) => n ()) -> IO ()
trigger' n = case (cast n) of
Just n' -> n'
Nothing -> error "n is not IO"
It says "No instance for (Typeable n) arising from a use of ‘cast’".
Why?
In practice I need the second form because in my program I use data types that have forall:
data Foo = Foo {a :: (Typeable n) => n ()}
trigger' :: Foo -> IO ()
trigger' (Foo n) = case (cast n) of
Just n' -> n'
Nothing -> error "n is not IO"

Answer 1

trigger :: (Typeable n) => n () -> IO ()
"For any n that is Typeable, I can turn a n () into an IO ()
trigger' :: (forall n. (Typeable n) => n ()) -> IO ()
"I can turn a value which can typed n () for every n that is Typeable into an IO ()"
The second doesn't really make sense; there are no values of the required type to give it (other than undefined). Even if there were, there would be no need to use cast; since the argument can be assigned every n () type you can just return it as is; it's already an IO () as a special case of being every n (), so you shouldn't even need trigger (except perhaps to pin down an ambiguous type). This is almost certainly not what you want.
The first signature is what you would need if you had an existential type; if you can build Foos containing any n () (provided it's Typeable), and you later want to be able to run them if they happen to contain an IO (). I suspect that this is actually what you want, and you have accidentally defined your data type incorrectly, rather than the problem being in trigger.
Consider this:
{-# LANGUAGE GADTs, RankNTypes #-}
module Foo where
import Data.Typeable (Typeable, cast)
data Foo = Foo { a :: Typeable n => n () }
data Bar = Bar { bar :: forall n. Typeable n => n () }
data Baz = forall n. Typeable n => Baz { baz :: n () }
trigger :: Typeable n => n () -> IO ()
trigger n = case (cast n) of
Just n' -> n'
Nothing -> error "n is not IO"
Your Foo is equivalent to Bar, not to Baz:
λ :t Foo
Foo :: (forall (n :: * -> *). Typeable n => n ()) -> Foo
*Foo
λ :t Bar
Bar :: (forall (n :: * -> *). Typeable n => n ()) -> Bar
*Foo
λ :t Baz
Baz :: Typeable n => n () -> Baz
The implicit forall is placed at the beginning of the type signature of the field a, rather than quantifying over the whole constructor. Consequently you've asked that the field a is forall n. Typeable n => n (), instead of the constructor working on any n () and the field containing some particular but unknown n ().
And we can see that Baz works with trigger the way you seem to want it to:
*Foo
λ case Baz (putStrLn "yay") of Baz x -> trigger x
yay
it :: ()
While for Foo, if you can get its field out you can use it directly as an IO () without needing any cast, but there's no way to actually put something into a Foo in the first place:
λ case Foo undefined of Foo x -> putStrLn "weird" >> x
weird
*** Exception: Prelude.undefined
Because "weird" is actually printed you can see that the type-checker accepted this expression; it was perfectly fine with the idea that the hypothetical contents of a Foo would be usable as an IO (), with no need for trigger at all. But I've handwaved-away the problem actually constructing a Foo in the first place; it's basically impossible without using something like undefined. This is what makes me think it's your data declaration that is incorrect, rather than trigger.
But if there's something about your real use-case that makes the data type wrapping a polymorphic field more reasonable (if there were more constraints than Typeable it could be possible to use), and it also doesn't work to simply dispense with trigger and make use of the contained polymorphism to "cast" to a more specific type, then we'll need more information to address your actual use case.