Export where()

[markfairbanks]

I was trying to reexport where() for my package that uses tidyselect, but the function isn't currently exported in v1.1.0.

library(tidyselect)

tidyselect::where
#> Error: 'where' is not an exported object from 'namespace:tidyselect'

[lionel-]

This is on purpose, for now.

[markfairbanks]

Ah gotcha. Is there a reason for this?

I currently have functions that have defaults like cols = where(is.character) that throw warnings using devtools::check(). Using the bare form cols = is.character is also flagged due to the warnings tidyselect generates.

[lionel-]

Just hesitance regarding using up a good function name. I think we'll end up exporting it anyway, since it'd probably be confusing to have different functionality for the same symbol. R CMD check note is a good point (altough easy to work around).

[CorradoLanera]

devtools::check() signals both usages:

E.g., assume it is used inside a dplyr::select() call as:

• tidyselect::where(<something>): NOTE: Missing or unexported object: ‘tidyselect::where’
• where(<something>): NOTE: no visible global function definition for ‘where’

How should we use {dplyr} & co. into a package using where and passing the checks? Should we Import {tidyselect}, or not?

[lionel-]

utils::globalVariables("where") for now.

[williamlief]

I just ran into the same issue with re-exporting tidyselect::where in my package. It would be nice if a note could be added to the documentation for where about this issue (my apologies if such a note does exist in the documentation and I just did not see it).

[lhmet]

I managed to make it work by doing:

1. Ensuring that the {tidyselect} dependency has been added to DESCRIPTION: usethis::use_package ("tidyselect")

2. Calling it using tidyselect::vars_select_helpers$where and importing it using
   #' @importFrom tidyselect vars_select_helpers

[lionel-]

@lhmet I would really recommend this instead:

utils::globalVariables("where")

globalVariables() is often the right and correct answer to static analysis problems with NSE functions.

[sclewis23]

Any idea when you will export where?

[lionel-]

Probably in the next version, but that's not high priority because the workaround is easy and non-invasive.

[NateNohling]

Writing my first package and still struggling with where() even after reading this thread.

I added this line into the function to define where, and then later call where(!is.list) in the function and it passes the CMD check fine.
where <- utils::globalVariables("where")

But when I run the package, I get an error.

Error in registerNames(names, package, ".global", add) :
The namespace for package "functions" is locked; no changes in the global variables list may be made.

Any ideas or updates on when we can just put tidyselect::where() into packages?

[lionel-]

Hello. You shouldn't assign where. Change this:

 where <- utils::globalVariables("where")

Into:

utils::globalVariables("where")

I don't know why you're getting this error message though. Where did you put the globalVariables() call? And what do you mean by "run the package"?

[petrbouchal]

@NateNohling @lionel- I ran into the same error because I put utils::globalVariables("where") inside a function definition - it needs to go outside. Apparently this is mentioned somewhere in the help page but I also had a hard time finding out where to put the call. See https://stackoverflow.com/questions/40251801/how-to-use-utilsglobalvariables.

[NateNohling]

@petrbouchal Ah...got it! That fixed it! Thanks

[evanmascitti]

How does one actually call this function inside a package once it is OK'd with utils::globalVariables() ? If using no accessor, I receive the message "can't find function where(). If I use ::: I still get a note from R CMD CHECK saying the ::: operator is frowned upon.

[lionel-]

where() is not meant to be evaluated by the R interpreter, only by the tidyselect interpreter. Selections are a DSL on top of R. (Unlike data-masking which is pure R)

[dkgaraujo]

Just coming here to add to the call for exporting where 😀.

[ramiromagno]

Idem.

[peterjuv]

Idem :)

[SimonDedman]

So per @petrbouchal 's link: add
#' @import utils
to the function param block, and
utils::globalVariables("where")
within the function script.

Edit: this didn't actually fix it. So if anyone knows how to do so, please say. I'm still getting:

Error in registerNames(names, package, ".global", add) :
The namespace for package "gbm.auto" is locked; no changes in the global variables list may be made.

(gbm.auto is my package name)

idem / +1 / samesies for exporting please. Cheers!

Edit2: Spacedman & DHW note that the utils::globalVariables("where") line has to be outside/under the function definition, which I understand to mean:

f <- function(params){
code
}
HERE

but that doesn't work for me either.

[lionel-]

It is likely that where() will be superseded in favour of anonymous functions, see #248.

[jjesusfilho]

It is likely that where() will be superseded in favour of anonymous functions, see #248.

I haven't been able to replace where() with an anonymous function in this case:

 df <- tibble::tibble(a = c(NA, NA, NA),
                       b = c(NA, 3,4),
                       c = c(NA, 5,6))

df <- df |> 
  dplyr::select(!where(~all(is.na(.x))))

[paladinic]

@jjesusfilho would discard() work?
example found here