[R] How to share variables

[Gabor Grothendieck]

On 8/21/06, Sergio Martino <s.martino at tno.it> wrote:
> Thanks for your fast replay and sorry for my late one (I was on holidays)
>
> The structure I would like to emulate (the fortran common statement) is a
> different from what you are describing.
>
> The examples "scoping" and the links to OO programming show the use of local
> variable which are tied to the object itself.
>
> My need is to have a group of (big) variable shared among some function in a
> way that they can be accessed freely.
>
> More useful is the environment example you reported. The only problem is
> that it seems I need to replace the whole environment of the function. What
> I need to investigate is where the variables created inside the inner
> function (myfun) go. If they belong to the enviroment (e) I will get a
> mix-up of variables with side effect (variables with the same name) and it
> will be a pain.

Each time myfun is run a new environment is created to hold
its local variables.  The parent of that environment is e in
this example by construction.  So e and the environment that
is temporarily created to hold myfun's variables are distinct.

Adding a couple statements to display what is in each might
help clarify this:

> e <- new.env()
> e$dat <- 1:3
> myfun <- function(x) {
+ cat("In current env:", ls(), "\n")
+ cat("In parent env:", ls(parent.env(environment())), "\n")
+ sum(x + dat)
+ }
> environment(myfun) <- e
> myfun(10)  # fun can access dat
In current env: x
In parent env: dat
[1] 36


>
> If I can use inside myfun the variable as e$dat (without changing the
> enviroment (no environment(myfun) <- e statement)) than it will be ok.

Yes you can.  You can either make sure that e is visible to myfun
via normal scoping rules or pass it explicitly:

e <- new.env()
e$dat <- 1:3
myfun <- function(x) sum(x + e$dat)
myfun(10)

# or passing e explicitly

myfun2 <- function(x, e) sum(x + e$dat)
myfun2(10, e)

# or using the proto package:to define e
# and the same myfun and myfun2

library(proto)
e <- proto(dat = 1:3)
myfun(10)
myfun2(10, p)

In the above examples we used environments but these are simple
enough that we could have used lists:

e <- list(dat = 1:3)
myfun(10)  # relying on scope rules
myfun2(10, e)  # passing explicitly

>
> I need to experiment a little bit.
>
> Sergio
>
>
>
>
> > On 8/2/06, Sergio Martino <s.martino at tno.it> wrote:
> > > Hi,
> > >
> > > I would like to realize in R a structure like the fortran common ie a
> way to
> > > declare some variable that can only be accessed by all the functions
> which
> > > need to.
> > >
> > > Browsing the archive it seems that the simplest way is to declare the
> > > variables and the functions in a big function which wraps all. But this
> is
> > > impratical when the functions are big.
> >
> > There is a demonstration of that found by issuing the command:
> >
> > demo(scoping)
> >
> > >
> > > The environments seems to do the trick but I am not enough familiar with
> > > them to make my ways out.
> >
> > Yes place your data in an environment as shown and then for
> > each function that is to access the environment should have
> > its environment set accordingly:
> >
> > e <- new.env()
> > e$dat <- 1:3
> > myfun <- function(x) sum(x + dat)
> > environment(myfun) <- e
> > myfun(10)  # fun can access dat
> >
> > Realize that what you are trying to do is to create a sort of object
> > oriented structure with the data being the objects and the functions
> > being the methods.  The proto package provides some functionality
> > to implement that and also supports delegation (similar to
> > inheritance):
> >
> > library(proto)
> > package?proto # all sources of info on proto
> >
> > # example - create proto object p with some data dat and a method fun
> > p <- proto(dat = 1:3, fun = function(., x) sum(x + .$dat))
> >
> > # invoke method
> > p$fun(10)  # runs fun.  fun has access to dat
> >
> > # create a child q of p and run fun
> > # q overrides dat with its own dat while inheriting fun
> > q <- p$proto(dat = 4:6)
> > q$fun(10)
> >
> > Another possibility would be to look at the R.oo package which is
> > another object oriented infrastructure based on environments.
> >
> > >
> > > Is there any example or pointers to easy but complete environment usage?
> > >
> > > Thanks in Advance
> > >
> > > Sergio Martino
>
>