View source for Determining the type of an expression

== Problem ==

How can I find out the type of an expression or a subexpression?


== Solution ==

=== Type of expressions ===

You can start the interactive environment of [[Hugs]] or [[GHC]] (GHCi)
and use the <code>:type</code> directive:

<haskell>
 Prelude> :type map fromEnum "Text"
 map fromEnum "Text" :: [Int]
</haskell>

If the expression is a top-level binding in a module,
you can use the <code>:info</code> directive.

<haskell>
 Prelude> :info map
 map :: (a -> b) -> [a] -> [b]
</haskell>

Using <code>:browse Modulename</code>
you can show the types of all top-level variables.
This way you can write many functions in a module
without a type signature, find them out and add them afterwards.
But be warned that due to the [[Monomorphism restriction]]
the automatically infered signatures
are not always the ones you want.

=== Type of subexpressions ===

Say, you have the expression <hask>map f "Text" == [1,2,3]</hask>
and you want to find out of what type the <hask>f</hask> must be.
This is also possible, just type

<haskell>
 Prelude> :type \ f -> map f "Text" == [1,2,3]
 \f -> map f "Text" == [1,2,3] :: Num a => (Char -> a) -> Bool
</haskell>

Here <hask>Bool</hask> is the type of <hask>map f "Text" == [1,2,3]</hask>
and <hask>Num a => (Char -> a)</hask> is the type of <hask>f</hask>.

Now imagine, that the function <hask>f</hask> cannot be chosen freely,
but is an instantiation of a polymorphic function.
E.g. of what concrete type is <hask>id</hask> in <hask>map id "Text"</hask>?

<haskell>
 Prelude> :type \ f -> map (id `asTypeOf` f) "Text"
 \f -> map (asTypeOf id f) "Text" :: (Char -> Char) -> [Char]
</haskell>

=== Using Data.Typeable ===

Say you'd like to catch a specific exception that is thrown, but you don't know which one it is. In the repl, you can catch SomeException and use <hask>Data.Typeable.typeOf</hask> on the value inside SomeException:

<haskell>
λ> import Data.Typeable
λ> let catcher (SomeException e) = print (typeOf e)
λ> let failer = openFile "foo" WriteMode >> openFile "foo" WriteMode >> print "opened twice"
λ> catch failer catcher
IOException
</haskell>


[[Category:FAQ]]