New subject: Constructing TH types

7 Oct 2012

      Nicolas, thanks for the welcome, and thanks for pointing out the additional 'Type' constructors!

I'd looked over the available constructors, but apparently not very well. The 'ListT', 'TupleT', 'ArrowT', etc., constructors are precisely what I need to make this work in a straightforward fashion.

So I don't actually have a problem making the right 'Name' value, just a problem reading the TH source. Well, that's that. ...

Many thanks,

Eric

On Oct 7, 2012, at 24:22 , Nicolas Frisby  wrote:
...
On Sat, Oct 6, 2012 at 2:24 PM, Eric M. Pashman  wrote:
...
Hello,
I'm using Template Haskell (which I've just begun to learn) to do "stanamic" type-checking. Basically I'm just converting 'TypeRep' and 'TyCon' values (from 'Data.Typeable') into Template Haskell's representation (i.e., values of the 'Type' datatype) and splicing them as type signatures in code where compile-time type inference is otherwise impossible.
Hi Eric. I'm going to try to answer each of your questions below, but
it's not entirely clear to me what you are trying to do. If you can
provide more context, we might be able to give better answers or
perhaps suggest alternative approaches.
...
My first thought was simply to make a TH 'Name' from the 'show' representation of a 'TypeRep', and turn that into a 'Type':
toType :: TypeRep -> Type
toType = ConT . mkName . show
This works for simple, atomic types like 'Int', but it chokes on compound types (I mean those with a type parameter, e.g. 'Maybe Int'.), for reasons I don't quite understand.
If I fire up ghci and enter the following
Prelude> :type Language.Haskell.TH.ConT
I get back (roughly) the answer: ConT :: Name -> Type
In particular, note that the argument to ConT is a name. Your code
indeed builds a name, but, in your example, it builds the invalid name
"Maybe Int". When I splice in the resulting type (ConT (mkName "Maybe
Int")), I get the error message
Not in scope: type constructor or class `Maybe Int'
ConT is only for a single named type; it cannot (by itself) represent
general types. Does that explanation get the big picture across?
In particular, it cannot (by itself) represent an applications of one
named type to another. The type "Maybe Int" can be correctly
represented as ConT (mkName "Maybe") `AppT` ConT (mkName "Int"). Or,
even better, as ConT ''Maybe `AppT` ConT ''Int. Those ''s are both two
occurrences of single quotes — very handy but less known TH syntax.
...
So I tried this instead:
toType tr = foldr (flip AppT . toType) (tcToType tc) trs where
   (tc, trs) = splitTyConApp tr
tcToType :: TyCon -> Type
tcToType = ConT . mkName . show
This works for both simple types and compound types made from standard prefix type-constructors, but it breaks on sugared constructors like '[]'; a 'TypeRep' for, say, '[Int]' gets turned into an invalid type that spliced in as '[] Int'.
Basically I don't quite understand how 'Name' construction and binding works. Is there a better way to make a 'Name' that will work with sugared type constructors, or do I have to special-case them while doing something like the above? (If so, what are all the special cases? Anything beyond lists and tuples?)
Someone else can surely better explain Name construction and binding.
I recall there being subtleties, but instead of internalizing them, I
have been fortunate in my needs to be able to avoid mkName altogether
(via the ' and '' syntax). It sounds like you might actually require
it for you needs though. Hopefully someone else chimes in.
Without more context, I'm not seeing an obviously more robust way that
will suite your needs.
One way to see which special cases there are is to fire up ghci and
look at the constructors of the Type type.
Prelude> :info Language.Haskell.TH.Type
data Type
 = ForallT [TyVarBndr] Cxt Type
 | AppT Type Type
 | SigT Type Kind
 | VarT Name
 | ConT Name
 | PromotedT Name
 | TupleT Int
 | UnboxedTupleT Int
 | ArrowT
 | ListT
 | PromotedTupleT Int
 | PromotedNilT
 | PromotedConsT
 | StarT
 | ConstraintT
 | LitT TyLit
There are some fancier things in these constructors like support for
universal quantification and promotion, but the three constructors
that I'm guessing you're most likely to be interested in as special
cases are TupleT, ArrowT, and ListT. These are all pretty much
pairwise interchangable, eg ArrowT for (ConT ''(GHC.Prim.->)) and
ListT for (ConT ''[]). And unless my experience is out-of-date with
respect to this now, sometimes TupleT doesn't always show up instead
of a type like (ConT ''(GHC.Tuple.(,,,))).
HTH.
...
Alternative approaches and general tips and hints are welcome as well. I'm fairly new to Haskell in general.
Welcome, enjoy, and good luck!
...
Regards,
Eric
PS: To compile the code above, you just need these imports:
import Language.Haskell.TH
import Data.Typeable (TyCon, TypeRep, splitTyConApp)
Here are some test cases:
import Data.Typeable (typeOf)
tr0 = typeOf (undefined :: Int)        -- Simple
tr1 = typeOf (undefined :: Maybe Int)  -- Compound, infix
tr = typeOf (undefined :: [Int])       -- Compound, sugared
_______________________________________________
Glasgow-haskell-users mailing list
Glasgow-haskell-users@haskell.org
http://www.haskell.org/mailman/listinfo/glasgow-haskell-users

Re: Constructing TH types

Eric M. Pashman

Nicolas Frisby

Eric M. Pashman

Eric M. Pashman

Simon Peyton-Jones

tags

participants (3)