I recently saw a function in R where someone had used . as an argument. I can't seem to find any documentation on this (other than the use of ellipsis or "dot-dot-dot"). Can someone either point me in the direction of documentation or provide an example of usage?
hello.world <- function(.) "Hello World"
# function(.) is what I'm asking about.
Dot is a a valid character in symbol names just like any letter, so . is no different than let's say a - it has no special meaning in this context. You can write things like:
> . <- 10
> . + .
[1] 20
It may look strange but is valid in R. The above use function(.) is let's say unusual, but syntactically valid. Since the author did not reference . in the function body, we will never know if he meant ... or just used it because he could.
While the answer given by Simon Urbanek is correct here's a reason the . is preferred over other characters as a function argument. In some situations, like lapply a function needs to receive an argument by design. But if there is no need of the argument inside the function we still need a dummy argument name. A . is the smallest character - almost invisible, so you are not distracted by what the function is delivering. The function(.) is as good as function() but has an advantage that it will not give an error when used in apply family.
The dot notation is frequently used in the map family for outer parameters. For instance, in map() function of the purrr package the .x parameter is a list or vector, and the .f parameter is a function of formula:
map(.x, .f, ...)
If we have a list dat_list we cannot make a reference to the dat_list inside the formula, as dat_list is not in the formula environment:
library(purrr)
map(dat_list, ~lm(var1 ~ var2, data = dat_list) )
Error in eval(predvars, data, env)
But we can reference the outer parameter inside the formula as .x:
map(dat_list, ~lm(var1 ~ var2, data = .x) )
