[Caml-list] Interfacing C++ and Ocaml

[Caml-list] Interfacing C++ and Ocaml

[David Chemouil]

Hi,



I am in the situation where I would like to write an Ocaml program which
makes use of some C++ classes. It seems to me some people had said there
were some problems doing so, but I can't recall what these problems may
be, and didn't find anything precise in the ML archive.

So, I would like to know what may prevent me to reuse C++ code from
Ocaml, if anything may. I am sure some arrangements can be done, as
there exists an Ocaml implementation on BeOS, which is programmed in
C++. 

Moreover, if it is possible, what do you advise me to do? What are the
limitations? Have you got simple examples of such interfacings?


Thanks in advance,

dc



PS: BTW, I would like to thank these happy volunteers who aim at
packaging a Caml Development Kit. IMO, this is truly a good idea, which
may help Caml spread. Just a question to the Caml team: I would like to
know if (when?) you intend to include polymorphic I/O and some kind of
overloading in a forthcoming release of Caml. It seems to me Pierre had
written some mails about this, but is is now a long time ago, how is the
situation today?


-- 
David Chemouil    [mailto:David.Chemouil@irit.fr]

Institut de recherche en informatique de Toulouse
-------------------
To unsubscribe, mail caml-list-request@inria.fr.  Archives: http://caml.inria.fr

Re: [Caml-list] Interfacing C++ and Ocaml

[Bruce Hoult]

At 10:54 AM +0200 3/30/01, David Chemouil wrote:
>Hi,
>
>
>
>I am in the situation where I would like to write an Ocaml program which
>makes use of some C++ classes. It seems to me some people had said there
>were some problems doing so, but I can't recall what these problems may
>be, and didn't find anything precise in the ML archive.
>
>So, I would like to know what may prevent me to reuse C++ code from
>Ocaml, if anything may. I am sure some arrangements can be done, as
>there exists an Ocaml implementation on BeOS, which is programmed in
>C++.

I'm no expert on Caml, so maybe the wizards have done something 
clever, but interfacing other languages to C++ is normally best done 
by writing an adaptor in C++ that provides a pure C interface to the 
C++ code (usable by C code, compiled by a C compiler, not C++), and 
then call *that* from your favourite language.

-- Bruce
-------------------
To unsubscribe, mail caml-list-request@inria.fr.  Archives: http://caml.inria.fr

Re: [Caml-list] Interfacing C++ and Ocaml

[Fergus Henderson]

On 30-Mar-2001, Bruce Hoult <bruce@hoult.org> wrote:
> I'm no expert on Caml, so maybe the wizards have done something 
> clever, but interfacing other languages to C++ is normally best done 
> by writing an adaptor in C++ that provides a pure C interface to the 
> C++ code (usable by C code, compiled by a C compiler, not C++), and 

In particular defining the C++ functions in your adaptor code
as `extern "C"' so that they can be called from C code.

-- 
Fergus Henderson <fjh@cs.mu.oz.au>  |  "I have always known that the pursuit
                                    |  of excellence is a lethal habit"
WWW: <http://www.cs.mu.oz.au/~fjh>  |     -- the last words of T. S. Garp.
-------------------
To unsubscribe, mail caml-list-request@inria.fr.  Archives: http://caml.inria.fr

Overloading again (Was Re: [Caml-list] Interfacing C++ and Ocaml)

[Brian Rogoff]

On Fri, 30 Mar 2001, David Chemouil wrote:
> PS: BTW, I would like to thank these happy volunteers who aim at
> packaging a Caml Development Kit. IMO, this is truly a good idea, which
> may help Caml spread. Just a question to the Caml team: I would like to
> know if (when?) you intend to include polymorphic I/O and some kind of
> overloading in a forthcoming release of Caml. It seems to me Pierre had
> written some mails about this, but is is now a long time ago, how is the
> situation today?

An even longer time ago I asked about overloading and got a nice long
reply from Francois Rouaix, describing the history of overloading in Caml
and ending with something like "Jun Furuse is now working on it". You can
read about the latest incarnation of his work by going to 

http://pauillac.inria.fr/jfla/2001/actes/index.html

and downloading 

Generic Polymorphism in ML

which as you can guess is in English unlike his paper last year. 

I'd also love to know if and when this will make it into Ocaml since this
is one of the few things that I dislike about ML style languages and
even after quite a bit of Caml programming I still miss overloading. 

-- Brian


-------------------
To unsubscribe, mail caml-list-request@inria.fr.  Archives: http://caml.inria.fr

Re: Overloading again (Was Re: [Caml-list] Interfacing C++ and Ocaml)

[Jean-Marc Alliot]

Brian Rogoff wrote:

> I'd also love to know if and when this will make it into Ocaml since this
> is one of the few things that I dislike about ML style languages and
> even after quite a bit of Caml programming I still miss overloading.
>

Well, I am going to be the black sheep again, but as an old ADA and C++ programmer,
I don't really want to see overloading pop up in ML.

Overloading can become easily a source of mistakes. My favorite example is the
following. A few years ago, I was managing a project with C++ code, and one of the
programmer was using a third party library (the author of this library was gone and
had been replaced). And he had a bug inside the following code fragment in that
library:

toto(titi *initp)
{
titi *p;

for (p=initp;p!=NULL;p++)
   {
     .......
   }

}

And it took him a very long time to realize that the ++ operator had been
overloaded, somewhere in a .h file included in an other .h file, and that instead
of incrmenting the pointer, it was doing something like p=p->next, with a next
field incorrectly initialized somewhere.

Having different names for different functions is, according to me, an excellent
thing.

JMA


-------------------
To unsubscribe, mail caml-list-request@inria.fr.  Archives: http://caml.inria.fr

Re: Overloading again (Was Re: [Caml-list] Interfacing C++ and Ocaml)

[Fergus Henderson]

On 02-Apr-2001, Jean-Marc Alliot <alliot@recherche.enac.fr> wrote:
> Well, I am going to be the black sheep again, but as an old ADA and C++
> programmer, I don't really want to see overloading pop up in ML.

Incidentally, it's "Ada", not "ADA".

> Overloading can become easily a source of mistakes. My favorite example
> is the following. A few years ago, I was managing a project with C++
> code, and one of the programmer was using a third party library (the
> author of this library was gone and had been replaced). And he had a
> bug inside the following code fragment in that library:
>
> toto(titi *initp)
> {
> titi *p;
> 
> for (p=initp;p!=NULL;p++)
>    {
>      .......
>    }
> 
> }
> 
> And it took him a very long time to realize that the ++ operator had
> been overloaded, somewhere in a .h file included in an other .h file,
> and that instead of incrmenting the pointer, it was doing something
> like p=p->next, with a next field incorrectly initialized somewhere.

This example is a bogus example, since C++ doesn't allow that kind of
overloading.  C++ requires that every overloaded operator have at least
one parameter whose type is a class, or a reference to a class,
an enumeration, or a reference to an enumeration (see e.g. 13.1.1.2
in the C++ standard).  In this case the argument has pointer type,
so it can't call an overloaded operator.

My opinion with regard to overloading is that what is really
problematic about overloading in C++ is the *combination* of
overloading and implicit conversions.

Mercury supports overloading, without implicit conversions,
in my experience it works fine.  The main drawbacks are that
(a) occaisionally you need to use explicit type annotations
to resolve ambiguities and (b) sometimes the presence of overloading
makes it harder for the type checker to issue good error messages.

-- 
Fergus Henderson <fjh@cs.mu.oz.au>  |  "I have always known that the pursuit
                                    |  of excellence is a lethal habit"
WWW: <http://www.cs.mu.oz.au/~fjh>  |     -- the last words of T. S. Garp.
-------------------
To unsubscribe, mail caml-list-request@inria.fr.  Archives: http://caml.inria.fr

Re: Overloading again (Was Re: [Caml-list] Interfacing C++ and Ocaml)

[Jean-Marc Alliot]

Fergus Henderson wrote:

> This example is a bogus example, since C++ doesn't allow that kind of
> overloading.  C++ requires that every overloaded operator have at least
> one parameter whose type is a class, or a reference to a class,
> an enumeration, or a reference to an enumeration (see e.g. 13.1.1.2
> in the C++ standard).  In this case the argument has pointer type,
> so it can't call an overloaded operator.
>

Right, it was back from a fragment of my memory. The example was slightly more
complex, but took as much time to be debugged.

>
> My opinion with regard to overloading is that what is really
> problematic about overloading in C++ is the *combination* of
> overloading and implicit conversions.

Yes (in C++ it is much more horrible because of implicit conversions) and no : it
is also bad in language like Ada (yes not ADA, right again, sorry lady Lovelace).
It is in fact forbidden to use overloading by many quality manuals, (and so is the
USE directive for example).  I hated that quality manual in the beginning, I now
consider that it is not as terrible as I thought when I was younger. From your
mail, I would say you're younger than I am... :-)


--
|             Jean-Marc Alliot          |
|  http://www.recherche.enac.fr/~alliot |
|         alliot@recherche.enac.fr      |



-------------------
To unsubscribe, mail caml-list-request@inria.fr.  Archives: http://caml.inria.fr

Re: Overloading again (Was Re: [Caml-list] Interfacing C++ and Ocaml)

[Brian Rogoff]

On Mon, 2 Apr 2001, Jean-Marc Alliot wrote:
> Fergus Henderson wrote:
> > My opinion with regard to overloading is that what is really
> > problematic about overloading in C++ is the *combination* of
> > overloading and implicit conversions.

I agree with Fergus on this. Clearly one can make a mess with overloading, 
but used with good taste it really makes programs better. I've always
found it interesting that fans of type inference tell us how great it is
not to be burdened with writing out explicit type information (which many 
programmers would consider helpful documentation) only to be left sticking
it onto function names. Labels help us a bit here (thanks Jacques!) but 
a little bit of overloading really helps.  

In C++, well, .... I agree that the combination of implicit conversions
and overloading is a disaster. 

> It is in fact forbidden to use overloading by many quality manuals,

Well, Jean Ichbiah and his Green team put it in so I imagine they thought
it could be used to write more maintainable code. Anyways, the AQS doesn't 
ban overloading but states the obvious

     Limit overloading to widely used subprograms that perform similar
     actions on arguments of different types (Nissen and Wallis 1984). 

and other obvious rules of thumb. 

> (and so is the USE directive for example). 

See "In Defense of the Use Clause" by Jean-Pierre Rosen at 

    http://perso.wanadoo.fr/adalog/publica2.htm

> I hated that quality manual in the beginning, I now
> consider that it is not as terrible as I thought when I was
> younger. From your  mail, I would say you're younger than I am... :-)

That's really not an appropriate way to argue, now is it? 

-- Brian


-------------------
To unsubscribe, mail caml-list-request@inria.fr.  Archives: http://caml.inria.fr

Re: Overloading again (Was Re: [Caml-list] Interfacing C++ and Ocaml)

[John Max Skaller]

Brian Rogoff wrote:
> 
> On Mon, 2 Apr 2001, Jean-Marc Alliot wrote:
> > Fergus Henderson wrote:
> > > My opinion with regard to overloading is that what is really
> > > problematic about overloading in C++ is the *combination* of
> > > overloading and implicit conversions.
> 
> I agree with Fergus on this. 

	This is not just a matter of opinion but mathematics.
There is a paper dealing with the interaction of generics
and implicit conversions which details conditions under which
both can coexist without ambiguity:

	Using Category Theory to Design Implicit Conversions
	and Generic Operators, John C  Reynolds, 
	Theoretical Aspects of Object-Oriented Programming,
	Gunter and Mitchell, MIT Press ISBN 0-262-07155-X


-- 
John (Max) Skaller, mailto:skaller@maxtal.com.au
10/1 Toxteth Rd Glebe NSW 2037 Australia voice: 61-2-9660-0850
checkout Vyper http://Vyper.sourceforge.net
download Interscript http://Interscript.sourceforge.net
-------------------
To unsubscribe, mail caml-list-request@inria.fr.  Archives: http://caml.inria.fr

Re: Overloading again (Was Re: [Caml-list] Interfacing C++ and Ocaml)

[Brock]

On Mon, 2 Apr 2001, Jean-Marc Alliot wrote:

|Brian Rogoff wrote:
|
|> I'd also love to know if and when this will make it into Ocaml since this
|> is one of the few things that I dislike about ML style languages and
|> even after quite a bit of Caml programming I still miss overloading.
|>
...
|
|And it took him a very long time to realize that the ++ operator had been
|overloaded, somewhere in a .h file included in an other .h file, and that instead
|of incrmenting the pointer, it was doing something like p=p->next, with a next
|field incorrectly initialized somewhere.
|

Wouldn't our lovely typechecking system take care of this?

--Brock
-------------------
To unsubscribe, mail caml-list-request@inria.fr.  Archives: http://caml.inria.fr

Re: Overloading again (Was Re: [Caml-list] Interfacing C++ and Ocaml)

[Hao-yang Wang]

>An even longer time ago I asked about overloading and got a nice long
>reply from Francois Rouaix, describing the history of overloading in Caml
>and ending with something like "Jun Furuse is now working on it". You can
>read about the latest incarnation of his work by going to 
>
>http://pauillac.inria.fr/jfla/2001/actes/index.html
>
>and downloading 
>
>Generic Polymorphism in ML
>
>which as you can guess is in English unlike his paper last year. 
>
>I'd also love to know if and when this will make it into Ocaml since this
>is one of the few things that I dislike about ML style languages and
>even after quite a bit of Caml programming I still miss overloading. 
>
>-- Brian


Well, I re-read Francois Rouaix's long email, and at the end he said:
>In this type system, we still have static type-checking and inference,
>but there are some practical problems: coherence (as always when you do
>powerful overloading), true separate compilation, but more significantly,
>you have to define all "instances" of an overloaded function in a single
>"generic" definition. In most cases, this is not what the user wants.

>From Jun Furuse's paper, it seems that we still have to define all 
"instances" of an overloaded function in a single generic" definition. If 
so, we cannot extend an existing function/operator, such as (+), to 
parameters of new types.

Is this true, or did I miss something in Jun's paper?

Cheers,
Hao-yang Wang
-------------------
To unsubscribe, mail caml-list-request@inria.fr.  Archives: http://caml.inria.fr

Re: Overloading again (Was Re: [Caml-list] Interfacing C++ and Ocaml)

[Sven LUTHER]

On Fri, Mar 30, 2001 at 12:41:43PM -0800, Hao-yang Wang wrote:
> >An even longer time ago I asked about overloading and got a nice long
> >reply from Francois Rouaix, describing the history of overloading in Caml
> >and ending with something like "Jun Furuse is now working on it". You can
> >read about the latest incarnation of his work by going to 
> >
> >http://pauillac.inria.fr/jfla/2001/actes/index.html
> >
> >and downloading 
> >
> >Generic Polymorphism in ML
> >
> >which as you can guess is in English unlike his paper last year. 
> >
> >I'd also love to know if and when this will make it into Ocaml since this
> >is one of the few things that I dislike about ML style languages and
> >even after quite a bit of Caml programming I still miss overloading. 
> >
> >-- Brian
> 
> 
> Well, I re-read Francois Rouaix's long email, and at the end he said:
> >In this type system, we still have static type-checking and inference,
> >but there are some practical problems: coherence (as always when you do
> >powerful overloading), true separate compilation, but more significantly,
> >you have to define all "instances" of an overloaded function in a single
> >"generic" definition. In most cases, this is not what the user wants.
> 
> >From Jun Furuse's paper, it seems that we still have to define all 
> "instances" of an overloaded function in a single generic" definition. If 
> so, we cannot extend an existing function/operator, such as (+), to 
> parameters of new types.

Could not some trick like the exception type be used, or maybe the polymorphic
variant ?

somethning like :


let f1 = function
  | 'A x -> xxx
  | 'B x,y -> xx


and later : 

let f1 = function
  | 'C x,y,z -> xxx
  | x -> f1 x

enrobed with some nice syntaxic sugar ?

Friendly,

Sven Luther
-------------------
To unsubscribe, mail caml-list-request@inria.fr.  Archives: http://caml.inria.fr

Re: Overloading again (Was Re: [Caml-list] Interfacing C++ and Ocaml)

[Sven LUTHER]

On Sun, Apr 01, 2001 at 10:15:02PM +0200, Sven LUTHER wrote:
> let f1 = function
>   | 'A x -> xxx
>   | 'B x,y -> xx
> 
> 
> and later : 
> 
> let f1 = function
>   | 'C x,y,z -> xxx
>   | x -> f1 x
> 

I was trold that this would not work, which after a bit of experimenting is
true :

        Objective Caml version 3.01
# let f1 = function
  | `A x -> 0
  | `B (x,y) -> 1;;
val f1 : [< `A of 'a | `B of 'b * 'c] -> int = <fun>
#  let f1 = function
  | `C (x,y,z) -> 3
  | x -> f1 x;;
This expression has type [? `C of 'a * 'b * 'c] but is here used with type
  [< `A of 'd | `B of 'e * 'f]

which is not cool, but the following works :

# exception Ea of int;;
exception Ea of int
# exception Eb of int * int ;;
exception Eb of int * int
# exception Ec of int * int * int ;;
exception Ec of int * int * int
# let f1 f = try f () with
  | Ea x -> 0
  | Eb (x,y) -> 1 ;;
val f1 : (unit -> int) -> int = <fun>
# let f2 f = try f () with
  | Ec (x,y,z) -> 2
  | exn -> let f () = raise exn in f1 f;;
val f2 : (unit -> int) -> int = <fun>
# let fa () = raise (Ea 1) ;;
val fa : unit -> 'a = <fun>
# let fb () = raise (Eb (1,2)) ;;
val fb : unit -> 'a = <fun>
# let fc () = raise (Ec (1,2,3)) ;;
val fc : unit -> 'a = <fun>
# f1 fa;;
- : int = 0
# f1 fb;;
- : int = 1
# f2 fc ;;
- : int = 2
# f1 fc;;
Uncaught exception: Ec (1, 2, 3).
# f2 fa;;
- : int = 0
# f2 fb;;
- : int = 1

So there may be some use for the introduction of extensible types (like the
exceptions) after all.

Friendly,

Sven Luther
-------------------
To unsubscribe, mail caml-list-request@inria.fr.  Archives: http://caml.inria.fr