Guillaume,
On Nov 29, 2009, at 13:57 , Guillaume Yziquel wrote:
Simon Urbanek a écrit :
On Nov 28, 2009, at 7:50 PM, Guillaume Yziquel wrote:
FWIW what I think you should be really looking at is
R_PreserveObject/R_ReleaseObject.
OK. Thanks.
I would suggest looking at the many other R embeddings in other
languages that already exist since I don't think you approach is
very viable (but I think I expressed that already before).
Lisp - the only thing I've seen is a translator:
http://dan.corlan.net/R_to_common_lisp_translator/
I haven't found a binding for Haskell. Nor for Scheme.
Do you know of any bindings of R to functional languages?
since I don't think you approach is very viable (but I think I
expressed that already before).
You expressed the sentiment that it would be a very bad idea to
bypass the current API. I would be happy to hear why you would think
that a low-level binding is not possible, or not very viable.
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).
You're talking about two entirely different things -- bypassing the
API is a very bad idea, but it has nothing to do with your last
paragraph. The API gives you access all user-visible aspects of R
which is all you really need for any embedding -- that includes
closure body, evaluation etc. I see no reason why you should ever go
lower than the API since that is unreliable and unsupported and thus
you won't get any help with that (that is IMHO the main reason why you
get no responses here - and I wouldn't expect any). All other
functions are hidden on purpose since they cover internal aspects that
should not be relied upon.
So again, I just think you're operating on the wrong level here -- and
this has nothing to do with the fact that you're binding to a
functional language since the mechanisms are the same regardless of
the languages (that's why Omegahat was used to bind into any random
language that seemed useful). You get more headaches since you have to
decide how to handle closures both ways, but I suspect the practical
solution is to use evaluators on the side where the function is
defined (especially for the R side since it includes non-S-language
code so you simply cannot map it).
If you have suggestions for extending the API, feel free to post them
with exact explanations how in general that extensions could be useful
(general is the key word here - I think so far it was rather to hack
around your way of implementing it). [And FWIW tryEval *is* part of
the API].
Cheers,
Simon
Please elaborate on the difficulties you perceive. That would be
helpful.
Cheers,
Simon
All the best,
Guillaume.
--
Guillaume Yziquel
http://yziquel.homelinux.org/
______________________________________________
R-devel@r-project.org mailing list
https://stat.ethz.ch/mailman/listinfo/r-devel
