Photo by Adli Wahid on Unsplash
Although operator overloading is generally a double plus ungood idea, it's good to know what a language is capable of, in case you find yourself in need of something in the future.
I recently discovered operator overloading in R.
Most R programmers know how to define a function:
> myfun <- function(x, y) x + y
> myfun(3, 4)
[1] 12
But you can also define a function with special symbols in its name, as long as you always surround that function name with backticks:
> `g^h` <- function(x, y) x + y
> `g^h`(3, 4)
[1] 12
R also provides the ability to create infix operators (operators which appear between their two arguments, like +). All you need to do is the above, but surround the function name with percent signs, as well:
> `%ytho%` <- function(x, y) x + y
> 3 %ytho% 4
[1] 7
As you can see above, when using infix operators, you can drop the backticks. This is precisely how the R pipe operator is defined:
> "%>%" <- function(x,f) do.call(f,list(x))
> sqrt(pi)
[1] 1.772454
> pi %>% sqrt
[1] 1.772454
At this point, you might think: "hey, maybe I can redefine | to be the pipe operator in R, like it is in most shells". You would be correct:
> "|" <- function(x,f) do.call(f,list(x))
> pi | sqrt
[1] 1.772454
But why don't we need percent signs around this function name? It's because you're actually not defining a new function, you're just overloading an existing one. In this case, it's the vectorised OR operator.
You can also do silly things like:
> "+" <- function(x, y) x * y
> 3 + 4
[1] 12
> 4 + 5
[1] 20
...though I strongly caution against that. (It's confusing and never necessary.)
Top comments (0)