A Package to Make R a Little Nicer

When I first started with R, there were a few things that bothered me greatly. While I can’t change dynamic typing, it is possible to do things such as:

1. String addition, subtraction, multiplication, and division
2. In-place modifiers (à la +=)
3. Direct assignments to only NA or regex-matched elements
4. Comparison operators for between, floating point equality, and more
5. Extra logical operators to make code more consistent
6. Make nicer (shorter) conversion functions (int() as opposed to as.integer())
7. Simple checks for usability (e.g is.bad_for_calcs())

The above functionality, I’d found myself manually adding into my R projects to clean up the code. Then me an my colleges thought: ‘that all might actually be useful as a package.’ So now it’s a package on CRAN: roperators (pronounced ’rop-er-ators, not r-operators)

To help introduce you to roperators, I put together some use cases where it’ll make your life easier.

1. String Arithmetic

One of the most common criticisms lobbed at R by Python people (and their wretched, non-curly-brace-using ilk) is the lack of string arithmetic. In a world without roperators one simply had to deny reality and insist that using a paste function doesn’t look any worse than simply using + to concatenate words.

Happily, using roperators, you can now do this:

require(roperators)
my_string <- 'using infix (%) operators ' %+% 'R can do simple string addition'
print(my_string)
## [1] "using infix (%) operators R can do simple string addition"

You can also use %-% to delete bits of text like so:

my_string %-% 'R can do simple string addition'
## [1] "using infix (%) operators "

If ever need to use string multiplication (like some kind of barbarian), you can use %s*% (%*% was taken already)

my_a <- 'a'
my_a %s*% 3
##     a 
## "aaa"
# If a is an unnamed vector, the original value is saved as the element name(s)
# just to make it easier to undo by my_a <- names(my_a)

And, something you can’t do in Python: string division

# How many times does the letter a appear in the string
'an apple a day keeps the malignant spirit of Steve Jobs at bay' %s/% 'a' 
## a 
## 8

String division also works with regular expressions (it is case sensitive):

# How many times is Steve Jobs or apple mentioned?
'an apple a day keeps the malignant spirit of Steve Jobs at bay' %s/% 'Steve Jobs|apple' 
## Steve Jobs|apple 
##                2

2. In-Place Modifiers (à la +=)

The lack of operators like += that you’d find in other languages is another common criticism of R. Happily, you have roperators.

Now, at the risk of sounding like one of those infomercials where people struggle with clearly trivial tasks, how many times do you end up doing something like this:

iris_data$Sepal.Length <- iris_data$Sepal.Length + 1

Or worse…

iris_data$Sepal.Length[iris_data$Species == 'setosa'] <- iris_data$Sepal.Length[iris_data$Species == 'setosa'] + 1
# ...which may not even fit on the page. 

Without roperators the trivial code above makes me envy the blind. After all, you’re only adding 1 to some values. So, using the greatest-best package formally called roperators:

iris_data$Sepal.Length %+=% 1

Or

iris_data$Sepal.Length[iris_data$Species == 'setosa'] %+=% 1
# ...which is ike a breath of fresh air

The current in-place modifiers included in roperators are:

• %+=%, %-=% – Add to and subtract from a variable. Also works on character strings
• %*=%, %/=%, and %^=% – Multiply, divide, and exponentiation a variable.
• %root=% and %log=% – Transform a variable by the nth root or log
• %regex=% – Apply a regular expression to text

The last two are similar depending on whether you want to modify the text or replace it outright. Note that they both take two values c(pattern, replacement):

x <- c("a1b", "b1", "c", "d0")
# Replace digits with the letter x
x %regex=% c("\\d+", "i")
 # x is now c("aib", "bi", "c", "di")
print(x)
## [1] "aib" "bi"  "c"   "di"

3. Replace Missing Values or Regex matches Directly

The last in-place modifiers are %na<-% which works as you’d expect and %regex<-% which is hopefully intuitive enough. This is useful for all those times you’d otherwise need to do something clunky like df$column[is.na(df$column)] <- 0

x <- c(NA, 1, 2, 3)
x %na<-% 0
print(x)
## [1] 0 1 2 3

And to replace by regex… (as opposed to modifying with %regex=%)

x <- c("aib", "bi", "c", "di")
x %regex<-% c('i', '[redacted]')
print(x)
## [1] "[redacted]" "[redacted]" "c"          "[redacted]"

4. Make More Comparisons Great(er) Again

This category of roperators is an answer to all those who cry out for help when what should be simple logical statements are either inconsistent looking or, such as the case with floating point equality, god-awful looking.

x <- c(NA, 'foo', 'foo', NA)
y <- c(NA, 'foo', 'bar', 'bar')

x %==% y
## [1]  TRUE  TRUE FALSE FALSE

x == y
## [1]    NA  TRUE FALSE    NA

(0.1 * 3) == 0.3  # FALSE
(0.1 * 5) == 0.5  # TRUE
(0.1 * 7) == 0.7  # FALSE
(0.1 * 11) == 1.1 # TRUE

(0.1 * 3) >= 0.3 # TRUE
(0.1 * 3) <= 0.3 # FALSE

(0.1 * 3)  %~=% 0.3  # TRUE
(0.1 * 5)  %~=% 0.5  # TRUE
(0.1 * 7)  %~=% 0.7  # TRUE
(0.1 * 11) %~=% 1.1  # TRUE

(0.1 * 3) %>~% 0.3 #TRUE
(0.1 * 3) %<~% 0.3 #TRUE

isTRUE(all.equal(0.1 * 3, 0.3))  # TRUE
isTRUE(all.equal(0.1 * 5, 0.5))  # TRUE
isTRUE(all.equal(0.1 * 7, 0.7))  # TRUE
isTRUE(all.equal(0.1 * 11, 1.1))  # TRUE


isTRUE(all.equal(0.1 * 3, 0.3)) | ((0.1 * 3) > 0.3)
isTRUE(all.equal(0.1 * 3, 0.3)) | ((0.1 * 3) < 0.3)
# I feel dirty even typing that as an example. 

5 %><% c(1, 10)  # TRUE
## [1] TRUE
1 %><% c(1, 10)  # FALSE
## [1] FALSE
1 %>=<% c(1, 10) # TRUE
## [1] TRUE
# note that due to my simple mindedness, at the time of writing, 5 %><% c(10, 1) is FALSE

5. Additional logicals for when you need something else

The last set of logical operators are not in, exclusive or, and all-or-nothing.

Not In %ni% was made because it’s just easier to read than negating an in statement. For example:

!1 %in% c(2,3,4)
## [1] TRUE

Which reads “not 1 in [2, 3, 4]?” which just looks wrong. So, we appropriated from the snake-like language:

1 %ni% c(2,3,4)
## [1] TRUE

Which now reads: “1 not in [2, 3, 4]?” That’s just better looking.

Exclusive Or exists in base R as a function, which makes it look inconsistent, for example:

if((a|b) & xor(y, z))

I know it’s finicky, but the roperators way is a touch more consistent:

if((a|b) & (y %xor% z))

That way both expressions are using an operator rather than one or statement using an operator while the other uses a function.

All or Nothing is for those occasions when you want a and b to either both be TRUE or both be FALSE – for two logical variables it’s probably easier to use a == b, but for expressions it can be cleaner:

if((a*2 == b+2) %aon% (x^2 == y*10))
# Compared to 
if((a*2 == b+2) == (x^2 == y*10)) 
# which takes my brain a little bit more time to read

But, like I said, that’s me personally being finicky.

6. Shorten type conversions

Fair warning: this part of roperators will, I’m sure, be the source of a lot of hate-mail.

x <- c('TRUE', 'FALSE', 'TRUE', 'TRUE')

percent_true <- paste0(sum(as.integer(as.logical(x))) / length(x)*100, '%')
print(percent_true)
## [1] "75%"

percent_true <- (sum(int(bool(x))) / length(x) * 100) %+% '%'
print(percent_true)
## [1] "75%"

7. Add more type checks

Sometimes you just want to know that everything is going to be okay. Rather than running multiple checks. If you wanted to be sure something was going to work in R, you could do something like this:

if(is.atomic(x) & (length(x) >= 1) & !is.na(x) & !is_nan(x) & !is.na(as.numeric(x)) & !is.factor(x) & !is.infinite(x) ){
  ...
}

…Which is fine if you’re happy with people thinking you’re a maniac, Or you could just use roperators like so:

if(!is.bad_for_calcs(x)){
  ...
}

And as a convenience function there’s also any_bad_for_calcs() to save you from any(is.bad_for_calcs((x)) because we’re nice like that.

Beyond that, you’ll also find:

• is.scalar()
• is.irregular_list()
• is.bad_for_indexing()

To help with basic checks, and for those times when something should either be a certain class or NULL:

• is.scalar_or_null()
• is.numeric_or_null()
• is.character_or_null()
• is.logical_or_null()
• is.df_or_null()
• is.list_or_null()
• is.atomic_nan() (I didn’t want to put it all by itself)

Bonus – Use roperators with magrittr

Some of you may have been thinking: “oh, so it’s like using magrittr to write cleaner code?” And, yes, it’s kind of the same idea – making R coding a bit nicer around the edges. Also like magrittr, it’s a tiny, self contained package so you can easily use it in production code. I use roperators and magrittr together religously and you should too. After all, why make things unpleasant for yourself when you don’t need to? Just think about how much more clean and tidy your R code could be if you used string arithmetic operators, in-place modifiers, direct replacement for missing values, better logical operators (especially for NA handling and floating point equality), terse conversions, simplified checks, and magrittr pipes!