On 11/17/08 18:24, Daniel Yokomizo wrote:
> On Mon, Nov 17, 2008 at 9:49 PM, Maurício <[EMAIL PROTECTED]
> <mailto:[EMAIL PROTECTED]>> wrote:
>
> > (...) I don't recall where I found the following example, but
> copied
>
> > it locally as compelling evidence that the functional solution
> can be
> > much clearer and shorter than the same solution modeled with
> objects
> > and inheritance.
[snip]
>
> > -- Arithmetic expression forms data Expr = Num Int | Add Expr Expr
> >
> > -- Evaluate expressions
> > eval :: Expr -> Int
> > (...)
>
>
> > public abstract class Expr {
> > public abstract int eval ();
> > public abstract void modn(int v);
[snip]
> when the first standard was set, and I can tell you for sure
that, even
> at that time, no one who knows at least the basics of C++
would ever
> write that problem like this.
Mauri, I'm not sure what you mean. Do you mean:
1) No C++er would ever "structure" the problem like:
-- Arithmetic expression forms
data Expr = Num Int | Add Expr Expr
-- Evaluate expressions
eval :: Expr -> Int
eval (Num i) = i
eval (Add l r ) = eval l + eval r
If so, then I'm unsure what you could mean since
the closest counterpart to:
date Expr = Num Int | Add Expr Expr
in c++ is an abstract Expr class with derived
classes, Int and Add, just as shown in Greg's Java counterpart to
the haskell Expr.
2) No C++er would every solve the problem with a heirarchy of Expr
classes with virtual functions.
If so, then I'm really confused because that's exactly the way I
would do it *except* if I wanted to avoid the overhead of
virtual function dispatch. In this case, I would use template
metaprogramming (WARNING: not for c++ template metaprogramming
novices):
http://www.boost.org/doc/libs/1_37_0/doc/html/proto/users_guide.html#boost_proto.users_guide.intermediate_form.expression_introspection.defining_dsel_grammars
In the proto metaprogramming, AFAICT, the 1st element of the
proto::expr template, the tag, corresponds to Expr constructor's,
Num and Add, of Greg's haskell example code. The | separating
the Expr constructor variants corresponds to the proto::or_
template.
So, if template metaprogramming were used, then there are some
very good c++ programmer which would structure their c++ code
like the haskell code (although, as seen by the
#boost_proto.users_guide.intermediate_form.expression_introspection.defining_dsel_grammars
reference, it's "a bit obscured" by all the "scaffolding" needed
to make it work).
Another reference which *may* reflect the haskell structure is:
http://research.microsoft.com/~akenn/generics/gadtoop.pdf
I must admit I don't really understand it, but it seems to have
some similarities to haskell's structure. The author even uses
haskell code to compare with his corresponding extension to
c#. In particular, page 9 contains an example use of his proposed
switch statement extension which looks very similar to the way
haskell would pattern match on an expression to dispatch to the
appropriate case.
[snip]
_______________________________________________
Haskell-Cafe mailing list
Haskell-Cafe@haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe
