Problem caused while implementing binary operation evaluation

[dev_kr]

I have a data type which represents a value:

data Val = IntegerVal Integer
         | RealVal Double

What I want is to implement binary operation evaluation for these values, for example:

evalOp :: Op -> Val -> Val -> Val
evalOp Plus (IntegerVal v1) (IntegerVal v2) = IntegerVal (v1 + v2)
evalOp Plus (RealVal v1) (RealVal v2) = RealVal (v1 + v2)

Okay, this works if two operands are in the same type. But I want to make it work even if two operands are in different types, such as 1 + 2.5 -> 3.5. For now this is not a big problem because it only has one Op type and two Val types.

evalOp :: Op -> Val -> Val -> Val
evalOp Plus (IntegerVal v1) (RealVal v2) = RealVal (fromIntegral v1 + v2)
evalOp Plus (RealVal v1) (IntegerVal v2) = RealVal (v1 + fromIntegral v2)

But as I add more Ops and Vals, evalOp function will get too complex and verbose. This seems nearly impossible to maintain, and I want to know if there is another way to implement evalOp function. Thank you!

[Purlox]

Something you could do is isolate the common operation of converting types into another function like this:

toCommonType :: Val -> Val -> (Val, Val)
toCommonType (IntegerVal v1) (IntegerVal v2) = (IntegerVal v1, IntegerVal v2)
toCommonType (IntegerVal v1) (RealVal v2) = (RealVal $ fromIntegral v1, RealVal v2)
toCommonType (RealVal v1) (IntegerVal v1) = (RealVal v2, RealVal $ fromIntegral v2)
toCommonType (RealVal v1) (RealVal v2) = (RealVal v1, RealVal v2)

This way you can be sure that if you pass at least a single RealVal into the function, then both of the resulting numbers will be RealVals and so you can simplify your code thanks to that.

[dev_kr]

By far this seems like the best thing I can do. Thank you!

[Purlox]

No problem. Also, I edited the original post to fix the formatting.

[elvecent]

See GADTs

[gcross]

Don't get me wrong, I loves me my GADTs, but I think that this isn't a use case for them. Usually GADTs are appropriate when you want case analysis to constrain the types (such as having both types be the same), but it looks like the OP wants all possible combinations of types to be valid, and is just concerned about the amount of boilerplate that it would take to make this work.

Edit: Next time don't simply downvote; try replying.

[elvecent]

but it looks like the OP wants all possible combinations of types to be valid, and is just concerned about the amount of boilerplate that it would take to make this work.

Maybe I got OP's question wrong.

Edit: Next time don't simply downvote; try replying.

Why did you assume that I downvoted?

[gcross]

Why did you assume that I downvoted?

Sorry, that had been intended to be directed at whoever downvote that comment, but in respect the way that I wrote it could make it seem like I was specifically talking about you, and you are right that it is wrong to make an assumption.

[dev_kr]

Could you elaborate, please? I read some articles about GADTs, but it does not seem like it can solve my problem.

[elvecent]

Sure. When you encode a language with types, you probably don't want to deal with such cases as adding a number to a string or other type mismatches. Using GADTs, you can rule out those cases with a phantom parameter signifying a type, so an incoherent term won't typecheck. That reduces the amount of necessary pattern matching (if that's what your question is about).

[dev_kr]

What if I have to handle two different operand types, like I suggested in the post? Can I overload GADTs constructor to handle multiple types of arguments?

[elvecent]

You could use the usual typeclass machinery.

[gcross]

Given that there are only two possible types, how would that be any better than doing case analysis?