R help - Sep 2016 - How to implement "zero-overhead" code re-use (a la Python, Perl, etc.) in R?

I'm collaborating in a long-running research project that, over the
years, has accummulated source code (written in-house) in several
languages: Python, Perl, Mathematica, MATLAB.

Recently I have started writing source code in R for this project, and
I am having trouble incorporating it into our established work flow.

Our code falls into two broad categories: "scripts" (invoked directly
by the user) and "libraries" (invoked by "client code", i.e.
scripts
or other library code).

The library code lives under the top-level subdirectory ./lib of the
git-controlled project directory.  (We keep all our code, along with
the rest of the project's documents, under git control.)

Users of client programs of the code under ./lib are expected to
supply (usually via some global configuration) the appropriate library
path (.e.g PYTHONPATH=$PROJECTDIR/lib/python,
MATLABPATH=$PROJECTDIR/lib/MATLAB, etc.).

With this arrangement, code re-use is extremely simple.  For example,
by just dropping into the ./lib/python directory the file foo.py, with
content

    # foo.py
    def bar():
        # etc.

...its bar function becomes *immediately* available, in a
namespace-safe way, to any other python code in the project, like
this:

    # somescript.py

    import foo

    foo.bar()

I describe this form of code re-use as "zero-overhead", since it
requires only the presence of files that actually hold the code.

Under such a code re-use scheme, updates of library code from the
project's git repo are no different from updates of the project's
content in general.  All that is required is running a command like

    git pull origin master

After such a command, the updated library code becomes immediately
available to client code.

Although I used Python for the example above, the picture is very
similar for the other languages we have been using up to now.

For R, however, the situation is different.  The only form of code
re-use I have found for R is through packages.  AFAICT, R packages are
not "zero-overhead": they entail a host of "meta" and
derived files
(in addition to the source code files), together with
build/installation steps after each update.

I'm looking for an alternative to packages for code re-use in R, one
that better approximates the "zero-overhead" code re-use model
described earlier.

The only thing that comes to mind is as follows:

  1. a "module" is an *.R file in the directory specified a suitable
environment variable (e.g. PROJECT_R_LIB), and defining a single
"module object", which is simply a named list.  For example,

    # module foo.R

    foo <- list(
      bar = function (...) ... ,
      baz = function (...) ... ,
      frobozz = function (...) ... ,
      ...
      opts = list(...),
      ...
    )

  2. every *.R file starts with boilerplate in the spirit of the
following (along with adequate error checking/messages, etc.):

    # somescript.R

    import <- function (module_name) {
      path_to_lib <- Sys.getenv("PROJECT_R_LIB")
      path_to_module <- file.path(path_to_lib, paste0(module_name,
".R"))
      source(path_to_module)
    }

    import("foo")
    ...
    import("whatever")

    foo$bar(...)
    if (foo$opts$frobnicate) foo$frobozz(...)


This implementation is very crude (I have very little experience with
R), but I hope it at least conveys clearly what I'm after.

I would appreciate any suggestions/comments on how to implement in R
the "zero-overhead" code re-use model I described earlier.

I believe that you should post this on the R-devel list. I think that
the expertise to give you an authoritative answer is likely to reside
there, and they may not monitor or wish to respond on this list.

Cheers,
Bert



Bert Gunter

"The trouble with having an open mind is that people keep coming along
and sticking things into it."
-- Opus (aka Berkeley Breathed in his "Bloom County" comic strip )


On Fri, Sep 30, 2016 at 7:36 AM, Kynn Jones <kynnjo at gmail.com>
wrote:
> I'm collaborating in a long-running research project that, over the
> years, has accummulated source code (written in-house) in several
> languages: Python, Perl, Mathematica, MATLAB.
>
> Recently I have started writing source code in R for this project, and
> I am having trouble incorporating it into our established work flow.
>
> Our code falls into two broad categories: "scripts" (invoked
directly
> by the user) and "libraries" (invoked by "client code",
i.e. scripts
> or other library code).
>
> The library code lives under the top-level subdirectory ./lib of the
> git-controlled project directory.  (We keep all our code, along with
> the rest of the project's documents, under git control.)
>
> Users of client programs of the code under ./lib are expected to
> supply (usually via some global configuration) the appropriate library
> path (.e.g PYTHONPATH=$PROJECTDIR/lib/python,
> MATLABPATH=$PROJECTDIR/lib/MATLAB, etc.).
>
> With this arrangement, code re-use is extremely simple.  For example,
> by just dropping into the ./lib/python directory the file foo.py, with
> content
>
>     # foo.py
>     def bar():
>         # etc.
>
> ...its bar function becomes *immediately* available, in a
> namespace-safe way, to any other python code in the project, like
> this:
>
>     # somescript.py
>
>     import foo
>
>     foo.bar()
>
> I describe this form of code re-use as "zero-overhead", since it
> requires only the presence of files that actually hold the code.
>
> Under such a code re-use scheme, updates of library code from the
> project's git repo are no different from updates of the project's
> content in general.  All that is required is running a command like
>
>     git pull origin master
>
> After such a command, the updated library code becomes immediately
> available to client code.
>
> Although I used Python for the example above, the picture is very
> similar for the other languages we have been using up to now.
>
> For R, however, the situation is different.  The only form of code
> re-use I have found for R is through packages.  AFAICT, R packages are
> not "zero-overhead": they entail a host of "meta" and
derived files
> (in addition to the source code files), together with
> build/installation steps after each update.
>
> I'm looking for an alternative to packages for code re-use in R, one
> that better approximates the "zero-overhead" code re-use model
> described earlier.
>
> The only thing that comes to mind is as follows:
>
>   1. a "module" is an *.R file in the directory specified a
suitable
> environment variable (e.g. PROJECT_R_LIB), and defining a single
> "module object", which is simply a named list.  For example,
>
>     # module foo.R
>
>     foo <- list(
>       bar = function (...) ... ,
>       baz = function (...) ... ,
>       frobozz = function (...) ... ,
>       ...
>       opts = list(...),
>       ...
>     )
>
>   2. every *.R file starts with boilerplate in the spirit of the
> following (along with adequate error checking/messages, etc.):
>
>     # somescript.R
>
>     import <- function (module_name) {
>       path_to_lib <- Sys.getenv("PROJECT_R_LIB")
>       path_to_module <- file.path(path_to_lib, paste0(module_name,
".R"))
>       source(path_to_module)
>     }
>
>     import("foo")
>     ...
>     import("whatever")
>
>     foo$bar(...)
>     if (foo$opts$frobnicate) foo$frobozz(...)
>
>
> This implementation is very crude (I have very little experience with
> R), but I hope it at least conveys clearly what I'm after.
>
> I would appreciate any suggestions/comments on how to implement in R
> the "zero-overhead" code re-use model I described earlier.
>
> ______________________________________________
> R-help at r-project.org mailing list -- To UNSUBSCRIBE and more, see
> https://stat.ethz.ch/mailman/listinfo/r-help
> PLEASE do read the posting guide
http://www.R-project.org/posting-guide.html
> and provide commented, minimal, self-contained, reproducible code.