From lgautier at gmail.com  Mon Nov 30 16:56:36 2009
From: lgautier at gmail.com (Laurent Gautier)
Date: Mon, 30 Nov 2009 16:56:36 +0100
Subject: [Rd] :Re:  PROTECT and OCaml GC.
In-Reply-To: <4B13DDB9.5060703@citycable.ch>
References: <mailman.15.1259578805.1160.r-devel@r-project.org>
	<4B13D956.7030608@gmail.com> <4B13DDB9.5060703@citycable.ch>
Message-ID: <4B13EB34.8090207@gmail.com>

Guillaume Yziquel wrote:
> 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.



[Rd] :Re: PROTECT and OCaml GC.
Laurent Gautier