Comparison of R object encoding with YAML, jsonlist and RJSONIO

As described in a prior post I need to save some configuration objects from R into human-readable, human-editable format.

I’d previously decided that YAML was the best for my purposes, but I recently discovered that YAML and jsonlite won’t keep the names of a named vector, whereas RJSONIO will.

In response to this discovery, I’ve decided to check a large number of standard R object types output by the three packages (yaml, jsonlite and RJSONIO) to get a better picture of their strengths and weaknesses.

Below, I set up a list of all the object I want to test and then test each package encoding/decoding the object and then comparing it to the original.

Set up the format specification and the list of R objects to test

#-----------------------------------------------------------------------------
# 3 formats and their encode/decode functions
#-----------------------------------------------------------------------------
format <- list(
  jsonlite = list(
    encode = jsonlite::toJSON,
    decode = jsonlite::fromJSON
  ),
  RJSONIO = list(
    encode = RJSONIO::toJSON,
    decode = RJSONIO::fromJSON
  ),
  yaml = list(
    encode = yaml::as.yaml,
    decode = yaml::yaml.load
  )
)


#-----------------------------------------------------------------------------
# List of different R objects
#-----------------------------------------------------------------------------
r_objects = list(
  
  null                    = NULL,
  empty_list              = list(),
  list                    = list(a=1, b='hello'),
  `NA`                    = NA,
  numeric_NA              = NA_real_,
  integer_NA              = NA_integer_,
  character_NA            = NA_character_,
  
  boolean                 = TRUE,
  numeric                 = 12.3,
  integer                 = 1L,
  character               = 'hello',
  
  boolean_vec             = c(TRUE, FALSE, FALSE),
  numeric_vec             = c(1.23, 4.56),
  integer_vec             = c(1L, 5L, 3L),
  character_vec           = c('a', 'b', 'c'),
  
  boolean_named_vec       = c(a=TRUE, b=FALSE, c=FALSE),
  numeric_named_vec       = c(a=1.23, b=4.56),
  integer_named_vec       = c(a=1L, b=5L, c=3L),
  character_named_vec     = c(a='a', b='b', c='c'),
  
  boolean_vec_with_na     = c(TRUE, FALSE, NA),
  numeric_vec_with_na     = c(1.23, NA),
  integer_vec_with_na     = c(1L, 2L, NA),
  character_vec_with_na   = c('a', 'b', NA),
  
  boolean_list            = list(TRUE, FALSE, FALSE),
  numeric_list            = list(1.23, 4.56),
  integer_list            = list(1L, 5L, 3L),
  character_list          = list('a', 'b', 'c'),
  
  boolean_list_with_null   = list(TRUE, FALSE, NULL),
  numeric_list_with_null   = list(1.23, NULL),
  integer_list_with_null   = list(1L, 5L, NULL),
  character_list_with_null = list('a', 'b', NULL),
  
  boolean_named_list      = list(a=TRUE, b=FALSE, c=FALSE),
  numeric_named_list      = list(a=1.23, b=4.56),
  integer_named_list      = list(a=1L, b=5L, c=3L),
  character_named_list    = list(a='a', b='b', c='c'),
  
  boolean_matrix          = matrix(TRUE, nrow=2, ncol=2),
  numeric_matrix          = matrix(1.2 , nrow=2, ncol=2),
  integer_matrix          = matrix(1L  , nrow=2, ncol=2),
  character_matrix        = matrix('a' , nrow=2, ncol=2),
  
  data.frame              = data.frame(a=1L, b=2.1, c='c', stringsAsFactors = FALSE)
)

Test each format encoding/decoding each R object

#-----------------------------------------------------------------------------
# Capture a string representation of an object
#-----------------------------------------------------------------------------
cap <- function(x) {
  deparse(x, control = c("keepInteger", "keepNA"))
}


sanitize <- function(x) {
  x <- gsub("\\.\\.\\.", '', x)
  x <- gsub("\n", "\\\\\\\\n", stringr::str_trim(x))
  x
}

#-----------------------------------------------------------------------------
# encode/decode the given r object using the given format
#-----------------------------------------------------------------------------
test_encode_decode <- function(format_name, r_object_name) {
  encode      <- format[[format_name]]$encode
  decode      <- format[[format_name]]$decode
  
  
  original_object <- r_objects[[r_object_name]]
  encoded_object  <- encode(original_object)
  decoded_object  <- decode(encoded_object)
  
  data_frame(
    format                 = format_name,
    name                   = r_object_name,
    original               = cap(original_object),
    decoded                = cap(decoded_object),
    original_class         = class(original_object),
    decoded_class          = class(decoded_object),
    identical              = identical(original_object, decoded_object),
    encoded_representation = sanitize(encoded_object)
  )
}


#-----------------------------------------------------------------------------
# Generate all results
#-----------------------------------------------------------------------------
all_results <- dplyr::bind_rows(
  names(r_objects) %>% purrr::map(~test_encode_decode('yaml'    , .x)) %>% bind_rows() %>% as.data.frame(),
  names(r_objects) %>% purrr::map(~test_encode_decode('jsonlite', .x)) %>% bind_rows() %>% as.data.frame(),
  names(r_objects) %>% purrr::map(~test_encode_decode('RJSONIO' , .x)) %>% bind_rows() %>% as.data.frame()
)

Warning: `data_frame()` is deprecated, use `tibble()`.
This warning is displayed once per session.

all_results %<>% mutate(
  name = factor(name, levels = unique(name))
) %>% arrange(name, format)

Results

The list of all results is at the end of this post in the appendix.

On a raw count, yaml has the most number of decoded objects identical to the original.

Notes

• YAML seems to have the best support for the basic types (i.e. the first 10 R objects tested)
• All formats convert an unnamed list of a single type (e.g. all numerics) into a vector
• Named vectors are only supported by RJSONIO
• Only jsonlite seems to support matrices

Conclusion?

It depends.

YAML still the best for my purposes.

Appendix: All results

knitr::kable(all_results, caption="All results")