Comments on: GADTs in C++

By: zerop

zerop — Thu, 08 Feb 2007 10:59:29 +0000

You could have used references instead of shared pointers, especially since you have immutable classes.

class Plus : public Exp {
public:
virtual int eval() const {
return lhs.eval() + rhs.eval();
}
explicit Plus(Exp const &lhs_, Exp const &rhs_)
: lhs(lhs_), rhs(rhs_)
{}
private:
const Exp &lhs, &rhs;
};

By: Ken

Ken — Sun, 06 Mar 2005 21:13:15 +0000

Oh, but I don’t claim to have done anything new with my embedding of the tiny expression language. And, as you say, somebodyelse have properly done something like this already. At least the matrix libraries that checks dimentions at compile time must have something similar. However, what is new is that Claudio and Andrew present a general and structured way of handling the embedding of the static semantics of a DSEL (at least they present one of the needed pieces).

In fact, I’m not really sure that the presented embedding of the expression language is really useful. Because often you want to be able to construct nonsense expressions, for example in a parser. But that example had the advantage that it was inspired by a publically available example by Peter Sestoft.

By: Asger Ottar Alstrup

Asger Ottar Alstrup — Sat, 05 Mar 2005 16:46:03 +0000

I agree that trying to implement this using the Boost variant is an interesting thought.

But the question on my mind is: Is this really new? I would have thought that one of the numerous expression template systems like

http://exmat.sourceforge.net/
http://research.microsoft.com/projects/greta/
http://www.boost.org/libs/numeric/ublas/doc/index.htm
http://www.oonumerics.org/blitz/
http://acts.nersc.gov/events/PI1999/pete/

etc. etc. would have compile time type safety for expressions already?

By: Ken

Ken — Sat, 05 Mar 2005 13:14:00 +0000

Yes, I know about the Boost variant library. I think the best way to compare my solution with a varient is to look at the Recursive variant types. The variant library coresponds roughly to ML and Haskell datatypes in C++. That is, if you remove all the template stuff from my solution then you get more or less the idiom that variant package into a library. Furthermore, variant makes a different tradeoff with respect to extensability of the datatype and certain forms of type safety at the C++ level (see my entry on the visitor pattern for a bit more discussion of the tradeoffs). But the variant example of embedding expressions does not enforce the type-safty of the embedded expressions. But I think you could use my technique (which is really Andrew, Claudio, and Peter’s technique) with the variant library. That would be an interesting experiment. Thus, I think that my technique complements the variant library.

With respect to AST (the language), as you say it is a DSL for generationg AST classes in C++, whereas my solution is a pattern/style/idiom for writting ASTs (or DSELs) manually. But if you look at the C++ classes generated by AST then they use a different (ugly) idiom. Also, I don’t think that AST will enforce type-safety of the embedded language. But AST could be changed to generate classes using my technique.

Hope this makes my writing more clear.

By: Asger Ottar Alstrup

Asger Ottar Alstrup — Sat, 05 Mar 2005 10:58:28 +0000

Do you know about the Boost variant library?

http://www.boost.org/doc/html/variant.html

How does this compare to your solution?

Also, how does this compare to AST:

http://www.cs.berkeley.edu/~smcpeak/elkhound/sources/ast/index.html

This is a Domain Specific Language which generates ASTs in C++.