2

I was helping somebody with their code recently and they asked me why it was possible to use functions from a certain package (e.g. dplyr) without explicitly 'loading' (and attaching them) to the search path within R.

Specifically, why it is possible to write:

dplyr::mutate(...)

As opposed to:

library(dplyr)

mutate(...)

When you use ::, it doesn't appear to automatically 'attach' the functions from the namespace dplyr onto the search path. That only happens when you call library(). This confuses me slightly: when you use the :: approach, how does R find the function mutate() within dplyr without it being attached to the search path?

Johnny
  • 285
  • 1
  • 7
  • you can read the documentation with ? '`'::'`' – D.J Mar 17 '22 at 09:29
  • So it says that the package namespace 'will be loaded if it was not loaded before the call (to `::`), but the package will not be attached to the search path'. Makes sense, but I thought that 'loading' a package and 'attaching to the search path' were synonymous: how does R locate the actual function inside a package without attaching it to the search path? – Johnny Mar 17 '22 at 10:11
  • 1
    The `::` call effectively explicitly tells R *not* to look in the search path, but to search in the package namespace instead. You can test this by trying to find a function that's not in `dplyr` and you can see it then ignores the search path altogether (e.g. `dplyr::mean` gives `Error: 'mean' is not an exported object from 'namespace:dplyr'`) – Andy Baxter Mar 17 '22 at 10:40

1 Answers1

1

You may also consider making use of with. with is traditionally is used to undertake operations on the data but combined with asNamespace can be used to access functions from the packages without the need to load the package.

with(asNamespace("dplyr"),
     select(mtcars, cyl) %>%
         mutate(cyl_two = cyl * 2)
)

You can use :: and ::: to access a single function from a package, accounting for exported or not exported functions. If you look at the code of double and triple colon operators you will see that those leverage very similar mechanism. Package name is used to construct an environment via asNamespace and get1 function is used to source the function.

Broadly speaking, a potentially efficient way of thinking about that is comparing package functions to objects in an environment. By calling ::, ::: or with we can reference those objects.

1 In case of :: the actual function is getExportedValue.

Konrad
  • 17,740
  • 16
  • 106
  • 167