Environment Working Group

[bundfussr]

Book Club Advanced R

Week 1: https://adv-r.hadley.nz/functions.html (Stefan)
Week 2: https://adv-r.hadley.nz/environments.html (Daniel)
Week 3: https://adv-r.hadley.nz/metaprogramming.html & https://adv-r.hadley.nz/meta-big-picture.html (Edoardo)
Week 4: https://adv-r.hadley.nz/expressions.html (Ben)
Week 5: https://adv-r.hadley.nz/quasiquotation.html
Week 6: https://adv-r.hadley.nz/evaluation.html

Week 7: Dive in to applications in {admiral}

[bundfussr]

Week 1: Functions

Lexical scoping may cause issues when users try to "functionalize" their code. Consider for example:

library(tibble)
library(dplyr)
library(lubridate)
time_window <- 30

adsl <- tribble(
  ~USUBJID, ~TRTEDT,
  "1",      ymd("2024-10-23")
)

adsl %>%
  mutate(AEREPEDT = TRTEDT + time_window)

Users may put the script and derivations in functions:

create_adsl <- function() {
  library(tibble)
  library(dplyr)
  library(lubridate)
  time_window <- 30

  adsl <- tribble(
    ~USUBJID, ~TRTEDT,
    "1",      ymd("2024-10-23")
  )

  derive_aerepedt(adsl)
}

derive_aerepedt <- function(dataset) {
  dataset %>%
    mutate(AEREPEDT = TRTEDT + time_window)
}

But this fails due to lexical scoping:

> create_adsl()
Error in `mutate()`:
ℹ In argument: `AEREPEDT = TRTEDT + time_window`.
Caused by error:
! object 'time_window' not found

Possible Actions:

• Provide guidance for users how to functionalize their code. This could be a vignette in admiral and/or a chapter in SAS and R.

[bms63]

Thanks for making a discussion!!

I'm hesitant to make this a vignette in admiral as this is a larger R programming topic, but what about just a pharmaverse blog post as we can show specific admiral code and keep the clutter to a minimum in admiral. This was my original intention with pharmaverse blog to showcase/discuss thing like this.

All for getting it included in SAS and R, but we don't have control of it and it might get out of date. unless we were just thinking this would be a general topic that doesn't include admiral

[bundfussr]

I've renamed the heading to "Possible Actions".

I think we should discuss at the end (Week 7) what we implement and where.

[jimrothstein]

@bundfussr
Good example of lexical scoping.
Will bring up during discussion:
Is make functions self-contained, ie add time-window as formal arugment to derive_aerepedt(), recommended fix??

[bms63]

So this is where I have always been lost with the environments here

admiral/R/admiral_environment.R

Line 14 in d5048cb

admiral_environment <- new.env(parent = emptyenv())

Why are we creating an empty environment? Isn't it already available as 7.2.3 says every environment has a Parent and the search path terminates with the empty environment

@bundfussr @ddsjoberg @manciniedoardo

[bms63]

So the admiral functions can search outside their enclosed environment if they can not find variables/information not already in that environment?

[bundfussr]

Yes, but this is not admiral specific. It is described in 6.4 Lexical scoping.

[bms63]

Sorry I got confused with the admiral_environment <- new.env(parent = emptyenv()) I thought this was restricting the search path of the admiral functions.

Understood on lexical scoping that a function looks up through the environments if it can't find variables/info needed in its enclosed environment and then terminates at the empty environment throwing an error.

[jimrothstein]

Probably tangential, but I think this (old -ish) R book has some diagrams and realistic examples for using environments. I find drawing envirnonment hierarchy helpful.
-https://rstudio-education.github.io/hopr/environments.html

For understanding, namespace vs environments ... I've read and re-read this. One day it will sink in. More code examples might help.

• https://blog.thatbuthow.com/how-r-searches-and-finds-stuff/

[bms63]

Ohhh this post looks good. Will try and take a look before the meeting

[bms63]

Do we create an R6 object as discussed in 7.6? Would that help us with some of our environment issues?

[bms63]

admiral/R/call_derivation.R

Line 128 in 269e021

if (!identical(fixed_env, variable_env)) {

if (!identical(fixed_env, variable_env)) {

This looks similar to section 7.3 Recursing over Environments - maybe a good discussion item as it is in context of admiral

[bms63]

For package loading - I've always "attached" packages in the beginning of the script just so it was clean, but reading 7.4.1 it feels like this is more important as if mid-script you "attach" other library the global environment changes

[bms63]

i guess namespaces help to solve this - but still the namespace won't have access to the package until its load mid-script

[bms63]

R avoids this problem by taking advantage of the function versus binding environment described above. Every function in a package is associated with a pair of environments: the package environment, which you learned about earlier, and the namespace environment.

The package environment is the external interface to the package. It’s how you, the R user, find a function in an attached package or with ::. Its parent is determined by search path, i.e. the order in which packages have been attached.

The namespace environment is the internal interface to the package. The package environment controls how we find the function; the namespace controls how the function finds its variables.

[jimrothstein]

I think search() is order dependent because it just follows chain of attached environments., as you said above.

I don't think NS places a role, yet.

[bms63]

Just putting these here to discuss at next EWG

[jimrothstein]

Holiday Reading !??

Many years ago, one of my freshman college roommates walked in the door speaking high praises for LISP.
For some of us, it takes a longer to catch on. Over the weekend, I read through the
"EVAL" chapter (Chapter 3) of Common LISP ( https://www.cs.cmu.edu/~dst/LispBook/)
(Tourteszky, Introduction to Common LISP - 1990).

"So that's what R is trying to do!"

Seems that LISP is cleaner way to introduce the
many list-like structures of R and how they built, passed, evaluated
or otherwise manipulated.

Then I read a chapter of this book and it too greatly helped with R. More light bulbs went on.

Metaprogramming in R
(https://www.amazon.com/exec/obidos/ASIN/1484228804/acmorg-20) by
Thomas Mailund (also:

More from Thomas Mailund:
https://mailund.github.io/r-programmer-blog/2018/09/20/scoping-rules-and-nse/)

[jimrothstein]

How R finds a dataset?

A month or so a ago we agreed to use the syntax:

x = package::dataset

Example, if one remembers the package (and spells it correctly)

pharamaversesdtm::ae

I don't quite understand the mechanism that serves up the dataset. It is not exported object, I tried to find it in the NS of the package (had much trouble with this). And we are using lazyload which has some affect on datasets, but I remain puzzled.

[jimrothstein]

This code came up today as an example of operator precedence.
(! is run last)

!x %in% y

I suggest another way to look at this code, equivalent. Mentally (or with lobstr::ast) break up this code into a list of one function followed by its arguments (! takes only one argument)

I think the list way of looking at R can simplify otherwise messy contructions.

(https://github.com/jimrothstein/try_things_here/blob/main/NSE_project/900_not_function.md)