[Haskell-cafe] Ambiguous types for collection keys

[Scott Weeks]

>
> Or carry an instance in along with a type parameter, using 
> existentials or GADT.
>
> Brandon Moore

Do you know of an example that would apply to my situation?

I think I neglected to state part of my problem. I am storing the root 
nodes of btree indexes in a heterogeneous list using Typeable. When 
they come out of the list they need to be unwrapped

I think this will clarify my situation because I've been doing a poor 
job of explaining:

import Data.Dynamic

data Foo a = FVal a
              deriving (Show, Typeable)

type FooStr = Foo String
type FooInt = Foo Integer

main = do
   fooType <- getLine
   fooVal  <- getLine
   let foo   = toDyn (FVal fooVal)
       fs    = [foo]
       (f:_) = fs
       Just dynFoo = fromDynamic f
   dostuff dynFoo



dostuff :: (Show a) => Foo a -> IO ()
dostuff (FVal x) = print x


This fails with:

  Ambiguous type variable `a' in the constraints:
       `Typeable a'
	arising from use of `fromDynamic' at 
/Users/weeksie/workspace/haskell/Main.hs:243:20-30
       `Show a'
	arising from use of `dostuff' at 
/Users/weeksie/workspace/haskell/Main.hs:247:2-8
     Probable fix: add a type signature that fixes these type variable(s)


However, changing main:

main = do
   fooType <- getLine
   fooVal  <- getLine
   let foo   = toDyn (FVal fooVal)
       fs    = [foo]
       (f:_) = fs
       Just dynFoo = fromDynamic f
   if fooType == "str"
      then dostuff (dynFoo::FooStr)
      else dostuff (dynFoo::FooInt)


Fails with:

     Couldn't match `Integer' against `String'
       Expected type: FooInt
       Inferred type: FooStr
     In the expression: dynFoo :: FooInt
     In the first argument of `dostuff', namely `(dynFoo :: FooInt)'



I'm probably going about this in the wrong way. I'd love some advice on 
how to either do it better or weave some Type Magic to achieve the same 
effect.