English version
Accueil     À propos     Téléchargement     Ressources     Contactez-nous    

Ce site est rarement mis à jour. Pour les informations les plus récentes, rendez-vous sur le nouveau site OCaml à l'adresse ocaml.org.

Browse thread
[ Home ] [ Index: by date | by threads ]
[ Search: ]

[ Message by date: previous | next ] [ Message in thread: previous | next ] [ Thread: previous | next ]
Date: 2009-03-04 (00:59)
From: Yoann Padioleau <padator@w...>
Subject: Re: [Caml-list] stl?
Jon Harrop <jon@ffconsultancy.com> writes:

> On Tuesday 03 March 2009 22:31:55 Yoann Padioleau wrote:
>> I don't know what are the Stepanov requirements, but C++
>> can do unboxed collections like  list<int>, which OCaml can
>> not provide I think. a 'int list' has boxed integers in OCaml.
> The currently OCaml implementation never boxes ints and the boxing of other 
> types (like float) is an artefact of the current implementation not found in 
> other language implementations like F# and my HLVM. Moreover, this is not 
> even a visible difference.

Oh, Ok. Is it true for other types such as list of records, 
list of variants, list of pairs, etc ? 

>> Also, a maybe good thing with STL is that you can write a single 'find'
>> or 'sort' function that will work for every kind of collections
>> (list, arrays, map, hash, etc) by using the
>> indirect iterator idiom, without the penalty of dynamic dispatch
>> solutions. I am not sure OCaml can do that too.
> OCaml can do that too. Just wrap your code in a functor and parameterize it 

The interesting word in your sentence is "just". The big problem with
functors is that it's never a "just". Functors are too intrusive. If
you have somewhere a function that needs to use this 'find', then you
will be forced to functorize the whole caller chain, including other
modules. That's really really really intrusive. It's exactly why
monads in haskell are mostly a bad idea. They are too intrusive. If in
haskell you have a deep nested function that needs to do some IO, then
you need to "monadize" the whole call chain which is just painful.

Imagine if the 'list' type would be in a functor and instead of 
'a list you would have a List: functor(T). Each time you have
a function using a list you would need to put it inside a functor...
In fact this happens for OCaml data-types such as Set or Map which
is why most people have defined their own defunctorized Set or Map
that just use Pervasive.(=).

That does not mean Functors or monads are completely a bad idea, they
have their use (I used them sometimes), but they have lots 
of drawbacks.

> over the module implementing the data structure (e.g. List or Array). Modules 
> and functors are second-class statically resolved constructs in OCaml so 
> there is no dynamic dispatch.
>> The question is do we really need those 2 things?
> Parameterizing code using functors is extremely useful but it goes far beyond 
> the usable capabilities of C++.

I think the next C++ has a 'concept' mechanism quite similar to
haskell typeclasse. But as usual with C++, it's wrapped in a ugly syntax 
way, will have awful error messages, and that will probably
makes it impossible in practice to be used by mere mortals.

>> I've worked a little bit with C++ using unboxed objects, that
>> is without introducing pointers (similar to boxing) in templates,
>> like list<figure> instead of list<figure*>, and passing them
>> as value in parameters, or returning them,
>> and it was far less efficient because there was lots of copy,
>> and you could not use then virtual method on them. So in the
>> end the C++ programmer I thing manually re-introduce boxing
>> when using STL if he wants good performance, and he can not really
>> rely either on the default copy/equal implementation provided
>> by those templates. So, yes STL makes it possible to do things,
>> but programmers don't want them, or only in very few cases where
>> one need extreme performance.
> The STL is extremely slow. If you want fast code in C++ then you drop to the C 
> subset. Alex Stepanov tried and failed to implement efficient constructs in 
> the STL. Furthermore, the memory consumption of his library is awful. OCaml's 
> GC is far more efficient with memory whilst permitting easy sharing.

I agree. Java is also better than C++ in that respect because
it also leverages sharing.

> -- 
> Dr Jon Harrop, Flying Frog Consultancy Ltd.
> http://www.ffconsultancy.com/?e
> _______________________________________________
> Caml-list mailing list. Subscription management:
> http://yquem.inria.fr/cgi-bin/mailman/listinfo/caml-list
> Archives: http://caml.inria.fr
> Beginner's list: http://groups.yahoo.com/group/ocaml_beginners
> Bug reports: http://caml.inria.fr/bin/caml-bugs