7

Does anyone know if there's a function in Haskell which does something like this:

"Int" -> Int

"String" -> String

"Bool" -> Bool

ie. it takes a string representation of a type constructor name, and converts it to the actual type constructor, both in an expression and in a pattern.

edit: My overall goal is to simplify something like:

transExp (Add exp1 exp2) vars
  = transExp exp1 vars ++ transExp exp2 vars ++ [IAdd]

transExp (Sub exp1 exp2) vars
  = transExp exp1 vars ++ transExp exp2 vars ++ [ISub]

Into a single pattern match, so basically convert Add or Sub to a string, add an "I" to the front, and convert it back to a type.

nponeccop
  • 13,527
  • 1
  • 44
  • 106
Jack
  • 2,153
  • 5
  • 28
  • 43
  • 3
    Is this even possible? Aren't the types a compile-time concept? What type would that function you are looking for have? – undur_gongor Nov 17 '11 at 10:12
  • I have no idea whether this is possible or not, I suppose it would have type String -> a, but I'm really not sure... – Jack Nov 17 '11 at 10:15
  • Take a look at template haskell then. Also `IAdd` is not a type but a type constructor - that was misleading. – nponeccop Nov 17 '11 at 10:41
  • 1
    Looking at your example it doesn't look like you want to convert a string to a type constructor, but you want to convert it to a value constructor. This might be possible using `read ("I" ++ x)`. But don't do it! There something wrong if you're using strings to convert between different types. – augustss Nov 17 '11 at 12:33

4 Answers4

10

There is a much better way to refactor your code here without any Template Haskell or reflection shenanigans by simply joining your Add and Sub cases into one:

data BinOp = Add | Sub | ...

data Expr = ...
          | BinOp BinOp Expr Expr
          | ...

transExp (BinOp op exp1 exp2) vars
    = transExp exp1 vars ++ transExp exp2 vars ++ [transOp op]
...

transOp Add = IAdd
transOp Sub = ISub

This way, we're using the data type to express directly the fact that binary operators are related, and therefore have similar translations. You can still pattern match on BinOp Add exp1 exp2 if you want to make a special case for addition somewhere.

hammar
  • 138,522
  • 17
  • 304
  • 385
3

In which context? There is Template Haskell and Data.Typeable, but for an actually helpful answer you need to provide more details.

Landei
  • 54,104
  • 13
  • 100
  • 195
0

Well, here's the problem.

"String" -> String

That's gibberish in Haskell-land, because "String" is a value but String is a type. So you might try this:

String -> a

This doesn't do what you want. You should learn how to read type signatures, because if you can't read type signatures, you're going to be badly handicapped at Haskell. The above type means, "Give me a string and I can give you a value of any type you request." There is a function in the prelude with this signature, it is called error, which is not what you want.

It sounds like you want something along these lines:

String -> TypeRep

Sorry, no such function. TypeRep does not instantiate the Read class.

What are you actually trying to do here? If you tell us what you are actually trying to do, we can help you with that problem rather than try to help with this problem.

Dietrich Epp
  • 205,541
  • 37
  • 345
  • 415
  • He is not talking about type names but about type constructors. He just want to generate some values and pattern matches from strings to avoid boilerplate. – nponeccop Nov 17 '11 at 11:27
  • 2
    @nponeccop: It's not exactly fair to downvote a answer after the question changes. This business about constructors is entirely new. – Dietrich Epp Nov 17 '11 at 11:37
0

You can't do it, because strings are runtime data and types have to be entirely resolved at compile time. The best you can probably do with your example is a helper function to eliminate some of the duplication:

helper exp1 exp2 vars op = transExp exp1 vars ++ transExp exp2 vars ++ [op]
transExp (Add exp1 exp2) vars = helper exp1 exp2 vars IAdd
transExp (Sub exp1 exp2) vars = helper exp1 exp2 vars ISub

But this may not actually be very useful in the long term, depending on how many cases you have.

In general, pattern matching is something that runs against type structures, so it has to be spelled out at compile type against concrete type constructors. This is the price you have to pay for having a really solid static type system.

Matthew Walton
  • 9,809
  • 3
  • 27
  • 36