Tibble silently changes recycled difftime variables - r

Question

If a difftime variable is included in a tibble, and the specified number of observations is equal to the other variable(s), then the class of the variable is maintained.
tibble::tibble(a = c(1,2), b = as.difftime(c(1,2), units = "hours"))
# A tibble: 2 x 2
a b
<dbl> <time>
1 1 1 hours
2 2 1 hours
However, if the specified number of observations in the difftime variable is a proper factor of the number of observations in the other variable, so that the difftime variable is recycled, then the class of the variable silently changes to numeric:
tibble::tibble(a = c(1,2), b = as.difftime(1, units = "hours"))
# A tibble: 2 x 2
a b
<dbl> <dbl>
1 1 1
2 2 1
Does this difference in behaviour occur because tidyverse users are encouraged to use the period or duration objects provided by lubridate to specify times, rather than base R's difftime objects? Or is this an unintended bug?
The same issue occurs when using tibble::data_frame, and dplyr::data_frame, although I believe these may be deprecated in the future.
To be clear, the following calls do not silently change the class of the time-type variable:
tibble::tibble(a = c(1,2), b = lubridate::as.period("1H"))
# A tibble: 2 x 2
a b
<dbl> <S4: Period>
1 1 1H 0M 0S
2 2 1H 0M 0S
tibble::tibble(a = c(1,2), b = lubridate::as.duration("1H"))
# A tibble: 2 x 2
a b
<dbl> <S4: Duration>
1 1 3600s (~1 hours)
2 2 3600s (~1 hours)

Answer 1

The behavior you are seeing stems from something quite peculiar with the vector recycling process during dataframe creations. As you already know, objects passed to the data.frame function should have the same number of rows. But atomic vectors will be recycled a whole number of times if necessary. This raises the question as to why the following does not work:
dff <- data.frame(a=c(1,2), b=as.difftime(1, units="hours"))
The code above raises the following error:
Error in data.frame(a = c(1, 2), b = as.difftime(1, units = "hours"))
: arguments imply differing number of rows: 2, 1
It turns out, the reason this does not work is because a vector of difftime objects is not recognized as an atomic vector. You can check with the following:
is.vector(as.difftime(1, units="hours"))
This returns:
[1] FALSE
As result, when the data.frame function tries to recycle the column b, it checks first if the column is in fact a vector (with is.vector). Since that returns FALSE, the recycling does not proceed; and hence the error returned.
So, the ensuing question is: why not just convert column b with as.vector?
This would have actually been a good idea, expect that as.vector removes all attributes, including names, for the resulting vector. You can see that with the following:
as.vector(as.difftime(1, units="hours"))
returns:
[1] 1
All the properties of the difftime object got lost during the coercion process. This leads me to think that the tibble::data_frame function actually uses as.vector somewhere along the process of generating the data_frame. As a result, we see the following behavior:
data_frame(a=c(1,2), b=as.difftime(1, units="hours"))
returns
# A tibble: 2 x 2
a b
<dbl> <dbl>
1 1 1
2 2 1
I guess the conclusion is the same as the one reached by #agstudy: to maintain the difftime object, you may have to use list for column b as follows:
tibble::tibble(a = c(1,2), b = list(as.difftime(1, units = "hours")))
I hope this proves, in some way, useful.

Answer 2

I don't think that tibble encourages the use of lubridate ( even if I encourage you to use it ) do deal with date like types , But it is more an issue of how are vector are created internally when you recycle. In fact you can reproduce the same recyclying behavior when you play with c and list. For example using c you will lose typing :
c(as.difftime(c(1), units = "hours"),1)
### Time differences in hours
### [1] 1 1
But using list will keep the time difference type :
list(as.difftime(c(1), units = "hours"),2)
# [[1]]
# Time difference of 1 hours
#
# [[2]]
# [1] 2
Applying list with tibble , you "conserve" the class type:
tibble::tibble(a = c(1,2),
b = list(as.difftime(c(1), units = "hours")))
# A tibble: 2 x 2
# a b
# <dbl> <list>
# 1 1 <time [1]>
# 2 2 <time [1]>
But this is hardly manipulated later. Better to use lubridate in this case.