Re: [Caml-list] C++ STL and template features compared with OCaml parametric polymorphism and OO features

[Radu Grigore <radugrigore@gmail.com>]

On Sun, 26 Sep 2004 02:34:50 +0100, Jon Harrop <jon@jdh30.plus.com> wrote:
> For example, to sum the floating-point elements of a container in C++, one
> might write:

This example is slightly unfair to C++. In the OCaml code:

> let sum fold_left c = fold_left ( +. ) 0. c
> sum List.fold_left [0.; 1.; 2.; 3.; 4.]
> sum Array.fold_left [|0.; 1.; 2.; 3.; 4.|]

...you use _two_ library functions (namely List.fold_left and
Array.fold_left). Surely you should at least use one for C++ :)

--- begin code ---
#include <vector>
#include <list>
#include <numeric>
#define ALLARRAY(a) (a), (a) + sizeof(a)/sizeof((a)[0])
#define ALL(c) (c).begin() (c).end()

int array[] = {0, 1, 2, 3, 4}; 
double ddata[] = {0., 1., 2., 3., 4.}; vector<double> dv(ALLARRAY(ddata));
int idata[] = {0, 1, 2, 3, 4}; list<int> il(ALLARRAY(idata));

int as = accumulate(ALLARRAY(array));
double ds = accumulate(ALL(dv));
int is = accumulate(ALL(il));
--- end code ---

The resulting C++ code is still uglyer than its OCaml counterpart. And
longer. But you should notice that the same accumulate function is
used for three different containers, while in OCaml you use one
function for each container type. OTOH, something that is maybe less
obvious in the code above, I do use conainer specific functions in
C++: namely begin and end.

So, in short: In OCaml you don't have iterators so the fold method is
container specific. In C++ you have iterators that allow a
container-independent "fold-like" function to be implemented. The C++
program is more verbose.

> Believe it or not, the previous example favours C++ more than most others.
> Check out this example of function composition from SGI's STL manual:

Using C++'s <functional> header (or Boost.Lambda for that matter) is
sure to give you a headache after programming a bit in a functional
language like OCaml. But the same can be said about writting
imperative code in OCaml.

I have recently compared two implementations of the same small program
in C++ and OCaml, both written by me. The OCaml one was 45% the size
of the C++ one (byte count). After compression (with bzip2) it was
67%. And it was kind of imperative job so C++ should have been in
advantage there. And I know C++ much better than OCaml, so this should
have been another advantage..

regards,
 radu
PS: ok, maybe it's unfair to ocaml now that I used macros..

-------------------
To unsubscribe, mail caml-list-request@inria.fr Archives: http://caml.inria.fr
Bug reports: http://caml.inria.fr/bin/caml-bugs FAQ: http://caml.inria.fr/FAQ/
Beginner's list: http://groups.yahoo.com/group/ocaml_beginners