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.)