:Re: PROTECT and OCaml GC.

It does not have to be a functional language.
To see it in use within a some-language-to-R bridge, you can check the
source in JRI, rpy2.
I can mostly speak for rpy2, and the way it is done there relies on both 
R and Python's GC. Creating a anonymous R object presented to the Python 
world is first "R_preserved" (from garbage collection from R) then using 
Python's reference counting mechanism, calling an "R_Release" whenever 
the Python wrapper is available for garbage collection (in fact there is 
a twist, but this is roughly the way it is working). In your case, 
you'll use the OCaml GC system (and "R_release" the R object when its 
OCaml representation is going for garbage collection).

By low-level, I mean a binding that takes hold of R objects without 
using symbols all over to reference them. (Using symbols in the
formals, the body or the environment of a closure is fine, for
instance, but I'd like to execute a closure directly, and eventually
be able to construct R closure from OCaml functions).

Rpy2 can do a lot of that, and probably so can JRI.

Laurent Gautier a ?crit :

It does not have to be a functional language.
To see it in use within a some-language-to-R bridge, you can check the
source in JRI, rpy2.
I can mostly speak for rpy2, and the way it is done there relies on 
both R and Python's GC. Creating a anonymous R object presented to the 
Python world is first "R_preserved" (from garbage collection from R) 
then using Python's reference counting mechanism, calling an 
"R_Release" whenever the Python wrapper is available for garbage 
collection (in fact there is a twist, but this is roughly the way it 
is working). In your case, you'll use the OCaml GC system (and 
"R_release" the R object when its OCaml representation is going for 
garbage collection).

For now, garbage collection is a secondary issue.

I would have been interested in a binding to a functional language to 
see exactly where you get a closure to closure mapping. That's why I was 
asking since that's what I'm foremost interested in.

By low-level, I mean a binding that takes hold of R objects without 
using symbols all over to reference them. (Using symbols in the
formals, the body or the environment of a closure is fine, for
instance, but I'd like to execute a closure directly, and eventually
be able to construct R closure from OCaml functions).

Rpy2 can do a lot of that, and probably so can JRI.

An anonymous closure to anonymous closure mapping? Could you point out 
where this is done exactly?

Anonymous R objects, that is without an associated symbol in R, can be 
passed to functions (and in that way makes a binding "take hold of R 
objects without using symbols").
For example, building R code made of anonymous objects can be achieved 
by making a LANGSXP object and tweaking it.

Example in R itself:

 > x <- call("round", 2.3)
 > eval(x)

[1] 2

 > x[[1]] <- function(x) x^2
 > eval(x)

[1] 5.29

Getting more complex constructs may need a little more trickery.

...or do you mean something else ?

L.

Laurent Gautier a ?crit :

Anonymous R objects, that is without an associated symbol in R, can be 
passed to functions (and in that way makes a binding "take hold of R 
objects without using symbols").
For example, building R code made of anonymous objects can be achieved 
by making a LANGSXP object and tweaking it.

Example in R itself:

 > x <- call("round", 2.3)
 > eval(x)

[1] 2

 > x[[1]] <- function(x) x^2
 > eval(x)

[1] 5.29

Getting more complex constructs may need a little more trickery.

...or do you mean something else ?

L.

You're saying "anonymous R objects can be passed to functions". My 
question is:

can you construct a LANGSXP in C/Python/rpy from R objects and an 
anonymous R closure, the closure being available from C as a SEXP 
closure. Can you write a function

    SEXP my_langsxp (SEXP closure, SEXP arglist);

with only the API?