Evaluating type expressions in GHCi

wagnerdm at seas.upenn.edu wagnerdm at seas.upenn.edu
Wed Sep 21 01:02:52 CEST 2011

Would it be possible to have no command at all? Types are  
distinguished by upper-case letters, so it should be possible to tell  
whether a given expression is a value-level or a type-level expression.

I guess that's not strictly true, since the expression could be _only_  
type variables -- but then I think it would be forgivable to just use  
the value-level evaluator for those ambiguous ones.


Quoting Simon Peyton-Jones <simonpj at microsoft.com>:

> Sean
> Yes, this has been asked for before, and it wouldn't be hard to implement.
> What should the GHCi command be *called*?
> We already have :kind, which displays the kind of a type.  Maybe  
> :kind! should evaluate the type as well?  Or perhaps :kind should  
> evaluate anyway (although that would be a bit  inconsistent with  
> :type which does not evaluate the expression)
> Or :normtype?   short for normalise type
> Simon
> From: glasgow-haskell-users-bounces at haskell.org  
> [mailto:glasgow-haskell-users-bounces at haskell.org] On Behalf Of Sean  
> Leather
> Sent: 20 September 2011 11:34
> To: GHC Users List
> Subject: Evaluating type expressions in GHCi
> I would like to ask GHCi for the type that a type expression will  
> evaluate to, once all definitions of type synonyms and (when  
> possible) type families have been inlined.
> It appears that I can do some part of this for type T by using ":t  
> undefined :: T":
> type family F a
> type instance F Int = Bool
> type instance F Bool = Int
> type instance F (a, b) = (F a, F b)
> ghci> :t undefined :: F (Int, Bool)
> undefined :: F (Int, Bool) :: (Bool, Int)
> I also get what I expect here:
> ghci> :t undefined :: F (a, Bool)
> undefined :: F (a, Bool) :: (F a, Int)
> Of course, this doesn't work on types of kinds other than *.
> Is it possible and worth having another GHCi command to perform this  
> operation for any types? It could be the type analogue to :t such  
> that it evaluates the type and gives its kind.
> Regards,
> Sean

More information about the Glasgow-haskell-users mailing list