NEWS.md
Subset assignment (“subassignment”) and also subsetting has become stricter. Symptoms:
Error: No common type for …
Error: Assigned data ...
must be compatible with …
i
must have one dimension, not 2
Error: Lossy cast from … to …
The “invariants” article at https://tibble.tidyverse.org/dev/articles/invariants.html describes the invariants that the operations follow in tibble, and the most important differences to data frames. We tried to make subsetting and subassignment as safe as possible, so that errors are caught early on, while introducing as little friction as possible.
List classes are no longer automatically treated as vectors. Symptoms:
Error: All columns in a tibble must be vectors
Error: Expected a vector, not a ...
object
If you implement a class that wraps a list as S3 vector, you need to include "list"
in the class:
Alternatively, implement a vec_proxy()
method as described in https://vctrs.r-lib.org/reference/vec_data.html, or construct your class with list_of()
.
Added experimental support for inner names for all columns, of the form tibble(a = c(b = 1))
. Inner names are no longer stripped when creating a tibble. They are maintained for slicing operations but not yet updated when assigning with a row subscript. This is a change that may break existing comparison tests that don’t expect names in columns (#630). Symptoms:
tibble()
now splices anonymous data frames, tibble(tibble(a = 1), b = a)
is equivalent to tibble(a = 1, b = a)
. This means that tibble(iris)
now has five columns, use tibble(iris = iris)
if the intention is to create a packed data frame (#581).
The name-repair
help topic is gone, refer to ?vctrs::vec_as_names
instead.
expression()
columns are converted to lists as a workaround for lacking support in vctrs (#657).
tribble()
is now stricter when combining values. All values in a column must be compatible, otherwise an error occurs (#204). The criteria for wrapping in a list column are now based on vctrs principles: non-vectors or vectors with vctrs::vec_size()
unequal 1 are wrapped in lists.
$
warns unconditionally if column not found, [[
doesn’t warn.
add_row()
now uses vctrs::vec_rbind()
under the hood, this means that all columns are combined with vctrs::vec_c()
. In particular, factor columns will be converted to character if one of the columns is a character column.
Soft-deprecate subclass
argument to new_tibble()
.
Soft-deprecate as_tibble()
without arguments (#683).
Preparing to move glimpse()
and tbl_sum()
to the pillar package. If your package implements these methods, please import the generics from pillar as soon as they become available there.
Internals now make heavy use of the vctrs package, following most of the invariants defined there. Name repair is the responsibility of vctrs now (#464).
All errors emitted directly by the package inherit from the "tibble_error"
and "rlang_error"
classes. In some cases, "vctrs_error"
errors may be passed through. The exact subclass is subject to change.
Example: tibble(a = quote(b))
raises an error that inherits from "tibble_error_column_must_be_vector"
, "tibble_error"
and "rlang_error"
, and from "error"
and "condition"
like all errors. Do not rely on the wording of "tibble_error_column_must_be_vector"
, this is likely to change.
Use the following pattern to catch errors emitted by tibble:
tryCatch( your_code(), tibble_error = function(cnd) { } )
New tibble_row()
constructs tibbles that have exactly one row, or fails. Non-vector objects are automatically wrapped in a list, vectors (including lists) must have length one (#205).
New as_tibble_row()
and as_tibble_col()
convert a bare vector to a one-row or one-column tibble, respectively. as_tibble_col()
also works for non-bare vectors. Using as_tibble()
for bare vectors is superseded (#447).
as_tibble.data.frame()
uses implicit row names if asked to create a column from row names. This allows lossless direct conversion of matrices with row names to tibbles (#567, @stufield).
Implement str.tbl_df()
(#480).
tribble()
now returns columns with "unspecified"
type for 0-row tibbles.
add_row()
and add_column()
now restore attributes to avoid errors when appending to sf objects or other tibble subclasses (#662).
add_column()
gains .name_repair
argument. If not given, .data
must have unique columns, with a deprecation message.
Allow POSIXlt
columns, they are now better supported by dplyr and other tools thanks to vctrs (#626).
view()
works for remote data sources by applying the same strategy as print()
and glimpse()
. The maximum number of rows in this case can be specified using the new n
argument, by default it is taken from the new "tibble.view_max"
option (#695).
Import lifecycle package (#669).
new_tibble()
removes redundant subclasses from the "class"
attribute.
Using classed conditions. All classes start with "tibble_error_"
and also contain "tibble_error"
(#659).
The magrittr pipe %>%
is reexported.
Three dots are used even for "unique"
name repair (#566).
add_row()
, add_case()
and add_column()
now signal a warning once per session if the input is not a data frame (#575).
Fix view()
for the case when an object named x
exists in the global environment (#579).
tibble names can again be set to NULL
within RStudio, as some R routines within RStudio relied on this behaviour (#563, @kevinushey).
as_tibble.matrix(validate = TRUE)
works again, with a lifecycle warning (#558).
Replace new_list_along()
by rep_along()
to support rlang 0.3.1 (#557, @lionel-).
The tibble()
and as_tibble()
functions, and the low-level new_tibble()
constructor, have undergone a major overhaul to improve consistency. We suspect that package code will be affected more than analysis code.
To improve compatibility with existing code, breaking changes were reduced to a minimum and in some cases replaced with a warning that appears once per session. Call tibble:::scoped_lifecycle_errors()
when updating your packages or scripts to the new semantics API to turn these warnings into errors. The compatibility code will be removed in tibble 3.0.0.
All optional arguments have moved past the ellipsis, and must be specified as named arguments. This affects mostly the n
argument to as_tibble.table()
, passing n
unnamed still works (with a warning).
new_tibble()
has been optimized for performance, the function no longer strips dimensions from 1d arrays and no longer checks correctness of names or column lengths. (It still checks if the object is named, except for zero-length input.) Use the new validate_tibble()
if you need these checks (#471).
The nrow
argument to new_tibble()
is now mandatory. The class
argument replaces the now deprecated subclass
argument, the latter will be supported quietly for some time (#518).
Setting names on a tibble via names(df) <- ...
now also requires minimal names, otherwise a warning is issued once per session (#466).
In as_tibble()
, checking names is also enabled by default, even for tibbles, matrices and other matrix-like objects: names must exist, NA
names are not allowed. Coercing a matrix without column names will trigger a warning once per session. (This corresponds to the "minimal"
checks described below.).
The validate
argument to as_tibble()
has been deprecated, see below for alternatives. (The as_tibble.tbl_df()
method has been removed, the as_tibble.data.frame()
method will be used for tibbles.)
as_tibble()
always checks that all columns are 1D or 2D vectors and not of type POSIXlt
, even with validate = FALSE
(which is now deprecated).
Calling as_tibble()
on a vector now warns once per session. Use enframe(name = NULL)
for converting a vector to a one-column tibble, or enframe()
for converting a named vector to a two-column tibble.
data_frame()
and frame_data()
are soft-deprecated, please use tibble()
or tribble()
(#111).
tibble_()
, data_frame_()
, and lst_()
are soft-deprecated. Please use tibble()
or lst()
(#111, #509).
as.tibble()
and as_data_frame()
are officially deprecated and not generic anymore, please use/implement as_tibble()
(#111).
as_tibble.data.frame()
(and also as_tibble.matrix()
) strip row names by default. Code that relies on tibbles keeping row names now will see:
rownames()
or row.names()
,NA
values when subsetting rows with with a character vector, e.g. as_tibble(mtcars)["Mazda RX4", ]
.Call pkgconfig::set_config("tibble::rownames", NA)
to revert to the old behavior of keeping row names. Packages that import tibble can call set_config()
in their .onLoad()
function (#114).
as_tibble()
drops extra classes, in particular as_tibble.grouped_df()
now removes grouping (#535).
column_to_rownames()
now always coerces to a data frame, because row names are no longer supported in tibbles (#114).
In all *_rownames()
functions, the first argument has been renamed to .data
for consistency (#412).
Subsetting one row with [..., , drop = TRUE]
returns a tibble (#442).
The print.tbl_df()
method has been removed, the print.tbl()
method handles printing (#519).
tibble()
supports columns that are matrices or data frames (#416).
The new .rows
argument to tibble()
and as_tibble()
allows specifying the expected number of rows explicitly, even if it’s evident from the data. This allows writing more defensive code.
Column name repair has more direct support, via the new .name_repair
argument to tibble()
and as_tibble()
. It takes the following values:
"minimal"
: No name repair or checks, beyond basic existence."unique"
: Make sure names are unique and not empty."check_unique"
: (default value), no name repair, but check they are unique
."universal"
: Make the names unique
and syntactic..name_repair = make.names
or .name_repair = ~make.names(., unique = TRUE)
for names in the style of base R).The validate
argument of as_tibble()
is deprecated but supported (emits a message once per session). Use .name_repair = "minimal"
instead of validate = FALSE
, and .name_repair = "check_unique"
instead of validate = TRUE
. If you need to support older versions of tibble, pass both .name_repair
and validate
arguments in a consistent way, no message will be emitted in this case (#469, @jennybc).
Row name handling is stricter. Row names are never (and never were) supported in tibble()
and new_tibble()
, and are now stripped by default in as_tibble()
. The rownames
argument to as_tibble()
supports:
NULL
: remove row names (default),NA
: keep row names,The old default can be restored by calling pkgconfig::set_config("tibble::rownames", NA)
, this also works for packages that import tibble.
new_tibble()
and as_tibble()
now also strip the "dim"
attribute from columns that are one-dimensional arrays. (tibble()
already did this before.)
Internally, all as_tibble()
implementation forward all extra arguments and ...
to as_tibble.list()
where they are handled. This means that the common .rows
and .name_repair
can be used for all inputs. We suggest that your implementations of this method do the same.
enframe()
(with name = NULL
) and deframe()
now support one-column tibbles (#449).
Improved S4 support by adding exportClass(tbl_df)
to NAMESPACE
(#436, @jeffreyhanson and @javierfajnolla).
New validate_tibble()
checks a tibble for internal consistency (#471).
Bring error message for invalid column type in line with allowed matrix/df cols (#465, @maxheld83).
view()
function that always returns its input invisibly and calls utils::View()
only in interactive mode (#373).The set_tidy_names()
and tidy_names()
helpers the list of new names using a bullet list with at most six items (#406).
A one-character ellipse (cli::symbol$ellipsis
) is printed instead of "..."
where available, this affects glimpse()
output and truncated lists (#403).
Column names and types are now formatted identically with glimpse()
and print.tbl_df()
.
tidy_names()
quotes variable names when reporting on repair (#407).
All error messages now follow the tidyverse style guide (#223).
as_tibble()
prints an informative error message when using the rownames
argument and the input data frame or matrix does not have row names (#388, @anhqle).
column_to_rownames()
uses the real variable name in its error message (#399, @alexwhan).
Lazy tibbles with exactly 10 rows no longer show “…with more rows” (#371).
glimpse()
shows information obtained from tbl_sum()
, e.g. grouping information for grouped_df
from dplyr (#550).
glimpse()
takes coloring into account when computing column width, the output is no longer truncated prematurely when coloring is enabled.
glimpse()
disambiguates outputs for factors if the levels contain commas (#384, @anhqle).
print.tbl_df()
with a negative value for n
behaves as if n
was omitted (#371).
Fixed output for extra column names that contain spaces.
Use fansi::strwrap_ctl()
instead of own string wrapping routine.
tibble()
uses recycled values during construction but unrecycled values for validation.
tibble()
is now faster for very wide tibbles.
Avoid use of stop()
in examples if packages are not installed (#453, @Enchufa2).
Fix as_tibble()
examples by using correct argument names in requireNamespace()
call (#424, @michaelweylandt).
as_tibble()
checks column length only once (#365, @anhqle).
Using rlang::list2()
(#391, @lionel-).
enframe(NULL)
now returns the same as enframe(logical())
(#352).tribble()
now ignores trailing commas (#342, @anhqle).The new pillar package is now responsible for formatting tibbles. Pillar will try to display as many columns as possible, if necessary truncating or shortening the output. Colored output highlights important information and guides the eye. The vignette in the tibble package describes how to adapt custom data types for optimal display in a tibble.
add_case()
an alias for add_row()
(#324, @LaDilettante).as_tibble()
gains rownames
argument (#288, #289).as_tibble.matrix()
repairs column names.`[.tbl_df`()
supports drop = TRUE
and omits the warning if j
is passed. The calls df[i, j, drop = TRUE]
and df[j, drop = TRUE]
are now compatible with data frames again (#307, #311).glimpse()
(#328).add_column()
from dropping classes and attributes by removing the use of cbind()
. Additionally this ensures that add_column()
can be used with grouped data frames (#303, @DavisVaughan).add_column()
to an empty zero-row tibble with a variable of nonzero length now produces a correct error message (#319).has_name()
from rlang, instead of forwarding, to avoid warning when importing both rlang and tibble.tibble()
call are recycled prior to evaluating subsequent arguments, improving consistency with mutate()
(#213).tibble()
call maintains their class (#284).add_row()
now always preserves the column data types of the input data frame the same way as rbind()
does (#296).lst()
now again handles duplicate names, the value defined last is used in case of a clash.validate
argument is now also supported in as_tibble.tbl_df()
, with default to FALSE
(#278). It must be passed as named argument, as in as_tibble(validate = TRUE)
.format_v()
now always surrounds lists with []
brackets, even if their length is one. This affects glimpse()
output for list columns (#106).glimpse()
(#280).tibble()
gives a consistent error message in the case of duplicate column names (#291).format()
and print()
methods for both tbl
and tbl_df
classes, to protect against malformed tibbles that inherit from "tbl_df"
but not "tbl"
, as created e.g. by ungroup()
in dplyr 0.5.0 and earlier (#256, #263).tidy_names(syntactic = TRUE, quiet = FALSE)
if not all names are fixed (#260, @imanuelcostigan).set_tidy_names()
and tidy_names()
, a simpler version of repair_names()
which works unchanged for now (#217).rowid_to_column()
that adds a rowid
column as first column and removes row names (#243, @barnettjacob).all.equal.tbl_df()
method has been removed, calling all.equal()
now forwards to base::all.equal.data.frame()
. To compare tibbles ignoring row and column order, please use dplyr::all_equal()
(#247).x
again instead of the Unicode multiplication sign, to avoid encoding issues (#216).print()
, format()
, and tbl_sum()
methods are now implemented for class "tbl"
and not for "tbl_df"
. This allows subclasses to use tibble’s formatting facilities. The formatting of the header can be tweaked by implementing tbl_sum()
for the subclass, which is expected to return a named character vector. The print.tbl_df()
method is still implemented for compatibility with downstream packages, but only calls NextMethod()
.print.data.frame()
anymore. Now providing format.tbl_df()
and full support for Unicode characters in names and data, also for glimpse()
(#235).rlang
instead of lazyeval
(#225, @lionel-), and rlang
functions (#244).tribble()
now handles values that have a class (#237, @NikNakk).any(is.na())
with anyNA()
(#229, @csgillespie).microbenchmark
package is now used conditionally (#245).pkgdown
website.mts
and ts
) are now supported in as_tibble()
(#184).all_equal()
function (called by all.equal.tbl_df()
) now forwards to dplyr
and fails with a helpful message if not installed. Data frames with list columns cannot be compared anymore, and differences in the declared class (data.frame
vs. tbl_df
) are ignored. The all.equal.tbl_df()
method gives a warning and forwards to NextMethod()
if dplyr
is not installed; call all.equal(as.data.frame(...), ...)
to avoid the warning. This ensures consistent behavior of this function, regardless if dplyr
is loaded or not (#198).as.tibble()
as an alias to as_tibble()
(#160, @LaDilettante).frame_matrix()
, similar to frame_data()
but for matrices (#140, #168, @LaDilettante).deframe()
as reverse operation to enframe()
(#146, #214).assertthat
.add_column()
can add columns of length 1 (#162, #164, @LaDilettante).x
if it cannot be represented in the current locale (#192, @ncarchedi).NA
names in printing (#206, #207, @jennybc).glimpse()
now uses type_sum()
also for S3 objects (#185, #186, @holstius).max.print
option is ignored when printing a tibble (#194, #195, @t-kalinowski).obj_sum
documentation (#193, @etiennebr).tribble()
(#191, @kwstat).tibble.width
option is used for glimpse()
only if it is finite (#153, @kwstat).as_tibble.poly()
to support conversion of a poly
object to a tibble (#110).add_row()
now correctly handles existing columns of type list
that are not updated (#148).all.equal()
doesn’t throw an error anymore if one of the columns is named na.last
, decreasing
or method
(#107, @BillDunlap).add_column()
, analogously to add_row()
(#99).print.tbl_df()
gains n_extra
method and will have the same interface as trunc_mat()
from now on.add_row()
and add_column()
gain .before
and .after
arguments which indicate the row (by number) or column (by number or name) before or after which the new data are inserted. Updated or added columns cannot be named .before
or .after
(#99).frame_data()
to tribble()
, stands for “transposed tibble”. The former is still available as alias (#132, #143).add_row()
now can add multiple rows, with recycling (#142, @jennybc).×
instead of x
when printing dimensions (#126). Output tests had to be disabled for this on Windows.dttm
instead of time
for POSIXt
values (#133), which is now used for columns of the difftime
class.print.tbl_df()
, now using data from nycflights13
instead of Lahman
(#121), with guidance to install nycflights13
package if necessary (#152).Follow-up release.
#
and contains more text (#95)), removed empty line, showing number of hidden rows and columns (#51). The trailing metadata also begins with hash #
(#101). Presence of row names is indicated by a star in printed output (#72).NA
values in character columns as <NA>
, like print.data.frame()
does (#69).glimpse()
shows nesting structure for lists and uses angle brackets for type (#98).POSIXlt
columns can be printed now, the text <POSIXlt>
is shown as placeholder to encourage usage of POSIXct
(#86).type_sum()
shows only topmost class for S3 objects.ncol
are supported. Passing a matrix or an array now raises an error in any case (#83).NULL
row names (#75).stop()
and warning()
are now always called with call. = FALSE
..Dim
attribute is silently stripped from columns that are 1d matrices (#84).as_tibble.data.frame()
preserves attributes, and uses as_tibble.list()
to calling overriden methods which may lead to endless recursion.has_name()
(#102).tibble()
and as_tibble()
over data_frame()
and as_data_frame()
in code and documentation (#82).is.tibble()
and is_tibble()
(#79).enframe()
that converts vectors to two-column tibbles (#31, #74).obj_sum()
and type_sum()
show "tibble"
instead of "tbl_df"
for tibbles (#82).as_tibble.data.frame()
gains validate
argument (as in as_tibble.list()
), if TRUE
the input is validated.as_tibble.default()
(#71, hadley/dplyr#1752).has_rownames()
supports arguments that are not data frames.as_tibble.tbl_df()
for subclasses (#60).knitr
internals for testing (#78).knitr
1.13 (#76).knit_print()
tests.tbl_sum.tbl_sql()
and tbl_sum.tbl_grouped_df()
to allow dplyr
release before a tibble
release.format_v()
(#98).NULL
value of tbl_sum()
.expect_output_file()
from testthat
.Initial CRAN release
Extracted from dplyr
0.4.3
tbl_df()
as_data_frame()
data_frame()
, data_frame_()
frame_data()
, tibble()
glimpse()
trunc_mat()
, knit_print.trunc_mat()
type_sum()
lst()
and lst_()
create lists in the same way that data_frame()
and data_frame_()
create data frames (hadley/dplyr#1290). lst(NULL)
doesn’t raise an error (#17, @jennybc), but always uses deparsed expression as name (even for NULL
).add_row()
makes it easy to add a new row to data frame (hadley/dplyr#1021).rownames_to_column()
and column_to_rownames()
(#11, @zhilongjia).has_rownames()
and remove_rownames()
(#44).repair_names()
fixes missing and duplicate names (#10, #15, @r2evans).is_vector_s3()
.as_data_frame.table()
with argument n
to control name of count column (#22, #23).tibble
prefix for options (#13, #36).glimpse()
now (invisibly) returns its argument (hadley/dplyr#1570). It is now a generic, the default method dispatches to str()
(hadley/dplyr#1325). The default width is obtained from the tibble.width
option (#35, #56).as_data_frame()
is now an S3 generic with methods for lists (the old as_data_frame()
), data frames (trivial), matrices (with efficient C++ implementation) (hadley/dplyr#876), and NULL
(returns a 0-row 0-column data frame) (#17, @jennybc).frame_data()
and tibble()
(including lists) creates list-valued columns (#7). These functions return 0-row but n-col data frame if no data.frame_data()
properly constructs rectangular tables (hadley/dplyr#1377, @kevinushey).setOldClass(c("tbl_df", "tbl", "data.frame"))
to help with S4 (hadley/dplyr#969).tbl_df()
automatically generates column names (hadley/dplyr#1606).tbl_df
s gain $
and [[
methods that are ~5x faster than the defaults, never do partial matching (hadley/dplyr#1504), and throw an error if the variable does not exist. [[.tbl_df()
falls back to regular subsetting when used with anything other than a single string (#29). base::getElement()
now works with tibbles (#9).all_equal()
allows to compare data frames ignoring row and column order, and optionally ignoring minor differences in type (e.g. int vs. double) (hadley/dplyr#821). Used by all.equal()
for tibbles. (This package contains a pure R implementation of all_equal()
, the dplyr
code has identical behavior but is written in C++ and thus faster.)data_frame()
and as_data_frame()
have been aligned, so as_data_frame()
will now automatically recycle length-1 vectors. Both functions give more informative error messages if you are attempting to create an invalid data frame. You can no longer create a data frame with duplicated names (hadley/dplyr#820). Both functions now check that you don’t have any POSIXlt
columns, and tell you to use POSIXct
if you do (hadley/dplyr#813). data_frame(NULL)
raises error “must be a 1d atomic vector or list”.trunc_mat()
and print.tbl_df()
are considerably faster if you have very wide data frames. They will now also only list the first 100 additional variables not already on screen - control this with the new n_extra
parameter to print()
(hadley/dplyr#1161). The type of list columns is printed correctly (hadley/dplyr#1379). The width
argument is used also for 0-row or 0-column data frames (#18).[.tbl_df()
does not change class (#41, @jennybc). Improve [.tbl_df()
error message.obj_type()
to obj_sum()
, improvements, better integration with type_sum()
.