On Monday 13 April 2009 1:18:40 am Anatoly Yakovenko wrote:
ah, Int vs Integer, i didn't see that at all. Thats kind of weird, i thought 1 could be either one.
It can, but typeOf has to pick one instance to use. The default for Num is Integer, so that's what it chooses without any annotation making it choose otherwise. If there weren't any defaulting rules, you'd just get an error saying that "typeOf 1" is ambiguous, and you'd need to add an annotation to say which instance you want.
This works
funResultTy (typeOf FooC) (typeOf (1::Int))
Yep, this tells it to use Int explicitly.
but
funResultTy (typeOf FooC) (typeOf $ fromIntegral 1)
Nothing
doesn't
fromIntegral 1 is the same as a literal 1, so this is not surprising.
so, how do i actually do something with this? is there a way that i can pull out the computation? Like there is a -> TypeRep, is there a TypeRep -> a function? cast doesn't seem to do what i want
let a::Foo = fromJust $ cast $ fromJust $ funResultTy (typeOf FooC) (typeOf (1::Int)) a
*** Exception: Maybe.fromJust: Nothing
I think you want Dynamics. TypeRep is just that, a value representing a type. There's no value of that type in it. The only reason typeOf takes a value of the given type is to specify what type you want a TypeRep of. So both: typeOf (undefined :: Int) typeOf (1 :: Int) return the same thing, a TypeRep representing Int. A Dynamic, on the other hand, can be looked at as a pair of a value and a TypeRep tag specifying its type, which sounds like what you want. Look at Data.Dynamic. As for your other question, a TyCon is a representation of a type constructor, not a data constructor. FooC and BarC are data constructors. Type constructors are more like Maybe, which take types to types. Although that TyCon type seems to take Foo (which would normally not be considered a type constructor proper, I think) as a type constructor too. Anyhow, both 'FooC 1' and 'BarC 2' have type Foo, so their type is Foo, and the 'constructor' part is Foo, according to the library. However, for instance: typeOf (Just ()) ==> Maybe () typeRepTyCon (typeOf (Just ())) ==> Maybe typeOf (Nothing :: Maybe ()) ==> Maybe () typeRepTyCon (typeOf (Nothing :: Maybe ())) ==> Maybe -- Dan