What’s New and Migrating Older Code

The NEWS entry of R 4.0.0 says that R now uses a stringsAsFactors = FALSE default, "and hence by default no longer converts strings to factors" in calls to data.frame() and read.table(), and adds that a large number of packages had relied on the previous behaviour and needed updating. read.csv() is read.table() with different defaults, so it follows. The older behaviour is still one argument away, which is how the first block reproduces it: stringsAsFactors = TRUE gives the nine-level factor that every older tutorial printed. With factors, adding a value that is not a level is a warning and an NA, the error message of the old days that this change retired for most scripts. The function default.stringsAsFactors() that old code used to read the default was deprecated in R 4.2.0 and is defunct since R 4.3.0, and the last line of the block shows its real message. The page Data Frames explains the argument and Factors explains what a factor is for.

Source: R NEWS: Changes in R 4.0.0

R 4.0.0 added a syntax for raw character constants similar to the one of C++: r"(...)", where the dots are any character sequence that does not contain the characters )". The NEWS says it makes it easier to write strings that contain backslashes or both single and double quotes, and refers to the help page of Quotes. The brackets may also be [] or {}, a capital R works as well as a small one, and a run of dashes between the r and the opening bracket (and again before the closing quote) lengthens the delimiter, so that a string may contain )" itself; the block shows the dashes. Raw strings matter most for Windows paths and regular expressions, where every backslash otherwise has to be doubled. They are a parser feature: the value is an ordinary character vector, as the identical() calls show. The syntax is explained in Syntax and Lexical Structure and used for patterns in Strings and Regular Expressions.

Source: R documentation: Quotes

Since R 4.0.0 a matrix has two classes, c("matrix", "array"). The NEWS entry warns that this "invalidates code incorrectly assuming that" the class of a matrix has length one, and adds that S3 methods for class "array" are now dispatched for matrices. The classic casualty is a test such as if (class(m) == "matrix"): with a condition of length two it was a warning before R 4.2.0 and is an error since R 4.2.0, as the fourth line of output shows. The correct tests are is.matrix() for "is this a matrix" and inherits() for a class vector. The lintr linter class_equals_linter() finds the old form (see the migration section). The page Matrices and Arrays covers the class vector in detail.

Source: R documentation: class

R 4.0.0 replaced the NAMED mechanism, with which R’s C code decided whether an object could safely be modified in place, by reference counting. The NEWS says it reduces the need for copying in some cases, should allow further optimisations, and is expected to have almost no impact on packages that use supported coding practices in their C and C++ code. For code written in R nothing changes: assignment never copies, and the copy is made when one of the two names is modified, which the block shows with the shelf’s pages column. What changed is how often R can skip the copy, and the way to observe it is tracemem(), which Memory and Copy Semantics and Assignment, Names and Values use. The header fields that hold the count are described in R Internals.

Source: R Internals: Rest of header

The default palette() has a new set of colours that are less saturated and have better accessibility properties, according to the NEWS. The old default is kept under the name "R3", the new built-in palettes are listed by palette.pals(), and palette.colors() selects a subset of colours from any of them. Charts that use the numbers 1 to 8 as colours (col = 2) therefore changed their look in R 4.0.0 even though their code did not; code that needs the old look sets palette("R3"). The block changes the palette and sets it back, because the palette is session state. The page Base Graphics and Devices shows the colours.

Source: R documentation: palette

list2DF() creates a data frame from a list of variables. Unlike data.frame(), it does not check or rewrite the names: data.frame() turns the name loan date into loan.date and 2nd copy into X2nd.copy, and list2DF() keeps both as given. It also takes an nrow argument for the case of a list with no columns. The R 4.2.0 NEWS adds that it checks that its arguments have the same length instead of recycling. See Lists and Data Frames.

Source: R documentation: list2DF

Source: R NEWS: Changes in R 4.0.0

The NEWS entry says that R now provides a simple native forward pipe syntax: the simple form inserts the left-hand side as the first argument of the right-hand side call. Before it, a pipe meant the magrittr package (2.0.5 here). The two look alike and differ in what they are. The magrittr %>% is an ordinary function that evaluates its right-hand side at run time and accepts a bare function name, an operator and the dot placeholder. The native pipe is a syntax transformation made by the parser: books |> head(3L) is read as head(books, 3L) and no pipe function is ever called, the right-hand side must be a call, and the placeholder is the underscore of the R 4.2.0 section below. The block runs both side by side and shows the transformation with quote() and the parse error for a right-hand side that is not a call. The magrittr lines carry a nolint comment because the linter pipe_consistency_linter() asks for one kind of pipe per file. Older code that works with magrittr keeps working; the page Pipes and the Native Pipe lists what has to change to move to the native pipe.

Source: R documentation: pipeOp

According to the NEWS, \(x) x + 1 is parsed as function(x) x + 1. The shorthand is not a new kind of function: the last identical() in the block compares the deparsed text of the two expressions and finds it equal. It is most useful where a function is passed as an argument and the word function is noise, as with vapply(). The block uses vapply() with a declared result type; the sapply() that older tutorials use for the same job can return a list or a matrix when the input changes, which is covered in Idioms and Common Pitfalls. See Operators and Precedence.

Source: R documentation: function

...names() returns the names of the arguments that were matched to ..., without evaluating them. Older code wrote names(list(...)), which evaluates every argument just to read the names, as the last two lines of the block show with an argument that fails when evaluated. The R 4.1.3 NEWS records that ...names() was changed to match names(list(...)) closely, so that the two agree on arguments without names (the empty string). See Functions.

Source: R documentation: dots

Source: R NEWS: Changes in R 4.1.0

The NEWS of R 4.2.0 says that calling if() or while() with a condition of length greater than one gives an error rather than a warning, and that the environment variable _R_CHECK_LENGTH_1_CONDITION_, which made the check strict in R CMD check, no longer has any effect. Before, only the first element was used, which hid bugs: a whole column of the shelf’s loans was silently reduced to its first loan. The fix is to say what is meant, with any(), all() or isTRUE(), and to decide what an NA means; if (NA) is an error of its own (see Control Flow). The block shows the error for if and for while and the two usual repairs.

Source: R documentation: Control

R 4.2.0 let a forward pipe use a named argument with the placeholder _ in the right-hand side call, to say where the left-hand side goes. The NEWS adds that the placeholder can appear only once, and the parser enforces both rules with messages of its own, shown in the block. The magrittr dot could be used several times and as .$name; the native placeholder is a named argument that appears once, and books |> lm(pages ~ year, data = _) is the shape to move magrittr code to. See Pipes and the Native Pipe.

Source: R documentation: pipeOp

From R 4.2.0, R uses UTF-8 as the native encoding on recent Windows systems (Windows 10 version 1903 or Windows Server 2022 or later, according to the NEWS), and as part of this change it uses the UCRT as its C runtime. The effect for scripts is that most encoding differences between a script on Windows and on Linux disappear, and that packages with compiled code are built with a UCRT toolchain (Rtools42 or later). This cannot be run in the Linux container that checked this page, so it is described from the NEWS and the pages that cover it: Encodings, Locales and Internationalization, Scripts and the Command Line and Interfacing C, C++ and Fortran.

Sys.setLanguage() is a new function that sets the language of messages and warnings, and the NEWS calls it "partly experimental". It sets LANGUAGE, flushes the cache of messages that have already been looked up, and returns the previous setting, which is why the block can restore it. Before, Sys.setenv(LANGUAGE = ...) was the idiom, and a message already looked up stayed in the old language. The container used for this page has the Spanish and German catalogues of R installed, so the two translated lines are real. See Encodings, Locales and Internationalization.

Source: R documentation: gettext

Source: R NEWS: Changes in R 4.2.0

The NEWS of R 4.3.0 says that calling && or || with a left-hand side or, if it is evaluated, a right-hand side of length greater than one is now always an error, with a report of the form 'length = 4' in coercion to 'logical(1)', and that the environment variable _R_CHECK_LENGTH_1_LOGIC2_ no longer has any effect. In R 4.2.x the same call gave a warning and used the first element. The block uses the returned vector of 60 loans for the first two calls (so the message says length = 60), then a right operand of length two. The short-circuit rule did not change: when the left operand decides the result, the right one is not evaluated, so FALSE && c(TRUE, FALSE) is FALSE without an error. The vectorised operators are & and |. See Operators and Precedence and Control Flow.

Source: R documentation: Logic

R 4.3.0 let the placeholder be used as the first argument of an extraction call, such as _$coef, and, more generally, as the head of a chain of extractions such as _$coef[[2]]. The NEWS introduces it with the words "as an experimental feature", so it may change. It saves a name or an anonymous function at the end of a pipe, as the block shows, and until it is settled the safe form is the one in the second half of the block. The page Pipes and the Native Pipe covers the syntax.

Source: R documentation: pipeOp

Source: R NEWS: Changes in R 4.3.0

The NEWS of R 4.4.0 describes x %||% y as an expressive idiom for if (!is.null(x)) x else y. Projects and packages defined their own copy (the rlang package has one too); a project that still defines it can delete the definition, because the base operator has the same meaning and is documented, rather surprisingly, on the help page of Control. Only NULL is replaced: NA, an empty string and a zero-length vector are values. The first block defines the old helper, uses it, removes it, and shows that the name now finds the operator in the base namespace. The operator lives in Operators and Precedence, and its use for optional arguments is in Defensive Programming and Input Validation. A script that must also run on R older than 4.4.0 keeps a guarded definition, shown in the section on keeping code portable.

Source: R documentation: Control

R 4.4.0 added the experimental functions Tailcall() and Exec() to support recursive functions that do not grow the stack. They are experimental: the help page says they may be changed or dropped in future releases. Plain recursion in R keeps one frame per call and stops with an error (node stack overflow here, evaluation nested too deeply in other cases); Tailcall() replaces the running call with the new one when it is the last thing the function does. The accumulator must be evaluated before the call, because an unevaluated argument would be passed as a chain of promises that is forced all at once at the end. The older workaround was a loop or a trampoline. See Function Factories and Higher-Order Functions.

Source: R documentation: Tailcall and Exec

sort_by() is a new generic function, "primarily useful for the data.frame method" that sorts the rows of a data frame by one or more columns. The columns are given as a formula (~ year + pages, later columns resolving ties in the earlier ones) or as a list, and further arguments such as decreasing = TRUE go on to order(). The result is the same as the older df[order(df$year, df$pages), ], as the first identical() shows, with row names that keep the original numbers. See Data Frames; the older idiom is the subject of R FAQ 7.23: How can I sort the rows of a data frame?.

Source: R documentation: sort_by

R 4.4.0 made is.atomic(NULL) return FALSE, "as NULL is not an atomic vector" in the words of the NEWS. The entry adds that strict backward compatibility would replace is.atomic(foo) by is.null(foo) || is.atomic(foo), but that this should happen only sparingly. The code that is affected is the code that used is.atomic() as the test for "plain data" and let a missing field through as a NULL. The block shows the new answer, the old test written out, and a vapply() over a record with a NULL field. See Atomic Vectors and Types and Missing and Special Values.

Source: R documentation: is.recursive and is.atomic

declare() is described in the NEWS as a new experimental primitive function "intended to eventually allow information about R code to be communicated to the interpreter, compiler, and code analysis tools", with a declaration syntax that is "still being developed". On R 4.6.1 it is a primitive that ignores its arguments and returns NULL invisibly, as the help page says, and the block confirms. There is nothing to migrate to and nothing to rely on: it is listed here so that the name is recognised when it is seen in newer code, and so that no script assigns a different meaning to it. The compiler that may one day use declarations is covered in Vectorisation and Iteration.

Source: R documentation: declare

At the C level, R 4.4.0 renamed the SEXP type S4SXP to OBJSXP, "to support experimenting with alternative object systems", with contributions from the R Consortium’s object-oriented programming working group (the NEWS also says the old name can still be used in C code but is deprecated). What an R user sees is the result of typeof(): an object of this type without the S4 bit reports "object", which is what an S7 object is, while an S4 instance still reports "S4" and a classed list is still a "list". The block uses S7 0.2.2 for the first line. S7 is a CRAN package, not part of base R; its stated goal is to be merged into base R eventually. The type is covered in OOP Overview and Base Types, The S7 Object System and S4 Classes and Methods; the C-level names are in R Internals.

Source: R Internals: SEXPTYPEs

use() attaches only the exports that are named, and always with attach.required = FALSE, so that the packages in Depends are not attached. It is the script counterpart of importFrom in a NAMESPACE: the help page says that a script written with use() can be turned into package code by replacing the calls with the corresponding importFrom directives. The R 4.5.0 NEWS lists it as a new function and adds in parentheses that it was "actually already available since R 4.4.0", which is why this page lists it under both releases. The help page calls the functionality still experimental, with interfaces that may change. The block loads tools the old way and the new way, and checks what each attached; code for R 4.3 or older uses library(pkg, include.only = ), which use() wraps. See Packages, Libraries and Namespaces.

Source: R documentation: use

Source: R NEWS: Changes in R 4.4.0

grepv() is grep() with value = TRUE as the default: the NEWS says it is identical to grep() except for the default of value. The older idiom grep(pattern, x, value = TRUE) keeps working, so there is nothing to migrate, only a shorter spelling; all other arguments (ignore.case, invert, fixed, perl) behave as in grep(). The block uses the trimmed shelf titles. See Strings and Regular Expressions.

Source: R documentation: grep

R 4.5.0 added the data sets penguins and penguins_raw to the datasets package, credited in the NEWS to Ella Kaye, Heather Turner and Kristen Gorman. penguins is a clean table with 344 rows and eight columns (species, island, bill and flipper measurements, body_mass, sex, year), and penguins_raw keeps the 17 columns of the original source, with their original names. Tutorials written before R 4.5.0 needed a data package or a CSV file for the same data; since R 4.5.0 data(penguins) is not even needed, because the data set is lazy-loaded when datasets is on the search path. The statistics pages of this reference use penguins where the shelf scenario does not fit, for instance Descriptive Statistics and Tests. The data sets are described in Reading and Writing Text Data.

Source: R documentation: penguins

The NEWS of R 4.5.0 lists use() as a new function "to use packages in R scripts with full control over what gets added to the search path", and adds that it was actually already available since R 4.4.0. The behaviour, the block and the status (experimental) are in the R 4.4.0 section above; this entry is the reason the issue tables of other sources give R 4.5.0 for it. A script that uses use() needs R 4.4.0 or later, not 4.5.0.

The package tools gained sha256sum() in R 4.5.0, analogous to md5sum() and implementing the SHA-256 hashing algorithm. MD5 is still available, but a script that records a checksum to detect tampering, as opposed to accidental corruption, should use SHA-256. The block writes a six-byte file, prints both digests, and shows that the 64-character SHA-256 digest changes with the content. The names of the result are the file paths, which unname() removes here so that no path is printed. The checksum of an extracted file is used in Connections and the File System, and R CMD build --sha256 can add a SHA256 file to a tarball (Creating Packages).

Source: R documentation: sha256sum

is.R() asked whether the code was running in R rather than in S-PLUS. The R 4.4.0 NEWS deprecated it "as no other S dialect is known to be in use", and the R 4.5.0 NEWS made it defunct and removed the effect of the environment variable _R_DEPRECATED_IS_R_. The name still exists, so a guard such as exists("is.R") && is.R() is true for the first operand and fails on the second; the block shows the real message. The repair is to delete the test, since the code runs on R. The R FAQ explains the relation between R and S in R FAQ 3.3: What are the differences between R and S?, and the deprecation process is described in Defensive Programming and Input Validation.

Source: R documentation: base-defunct

R 4.5.0 selects a C23 compiler by default, if one is available, for compiling R and packages. The NEWS lists the compilers known to select C23 (gcc 13 to 15 and recent clang releases, among them) and the ways out: a package can ask for the previous standard with USE_C17 in SystemRequirements, or an installer with R CMD INSTALL --use-C17, and R itself can be built with --without-C23 unless the compiler defaults to C23 anyway. C23 rejects implicit function declarations and K&R-style definitions, so old C code needs fixing or the request for C17. Strict R headers are also the default in R 4.5.0, which removes the legacy macros PI, Calloc, Realloc and Free; the replacements are M_PI, R_Calloc, R_Realloc and R_Free. This is a matter for packages with compiled code and cannot be shown in a script that runs under Rscript; Interfacing C, C++ and Fortran covers it with compiled examples.

Source: R NEWS: Changes in R 4.5.0

x %notin% table is the negation of x %in% table. The NEWS describes it as an idiom for !(x %in% table), "provided almost entirely for convenience and code readability" after many years of private definitions, mostly hidden in packages. Projects that define their own operator of the same name can delete the definition once they require R 4.6.0 or later. Because it is built on match(), NA is treated as a value, as with %in%. The block compares the three spellings on the shelf’s genres. See Operators and Precedence, where the membership operators are explained.

Source: R documentation: match

messageCondition() creates a structured "message" condition object, analogous to errorCondition() and warningCondition() (R 3.6.0). The extra arguments become fields of the condition and class adds classes in front of c("message", "condition"), so a handler can select on the class and read the fields, which is how progress messages that carry data are written. Before, the object was assembled by hand with structure(), as the first lines of the block do; both produce the same classes. See Conditions and Error Handling.

Source: R documentation: conditions

bitstring() is a user-friendly wrapper around intToBits() and its relatives, and its help page says it is inspired by the Julia function of the same name. It supports integer, numeric and raw vectors and prints the bits with a separator after the sign bit and, for doubles, between the exponent and the mantissa. The first lines of the block show the older way to print the low eight bits of an integer. See Numbers and Arithmetic.

Source: R documentation: bitstring

match.arg() takes a new value for several.ok. A string that starts with "all" means that the argument may have more than one element and that every one of them must match choices. With several.ok = TRUE, the older option, elements that do not match are dropped without a word, which let typos through; the block shows both. The tests of valid values that people wrote by hand after several.ok = TRUE can be replaced. See Functions and Defensive Programming and Input Validation.

Source: R documentation: match.arg

substring(txt, i1, i2), substr() and their replacement versions accept i2 = NULL to mean "to the end of the string". Before, substring(x, i) already ran to the end through its default, while substr() needed nchar(x); the block shows the older spelling and the new one, and a replacement. See Strings and Regular Expressions.

Source: R documentation: substr

hist() gains panel.first, and barplot() and boxplot() (through bxp()) gain panel.first and panel.last; hist() has no panel.last. They draw before and after the data, which is what a background grid needs, and before R 4.6.0 the usual place to find them was plot.default(). hist() and barplot() evaluate the argument as an expression, while boxplot() expects a function, which is why the block writes \() grid(). The block draws on a null PDF device so that nothing is written. See Base Graphics and Devices, where the real chart is shown.

Source: R documentation: bxp

The NEWS of R 4.6.0 says that the default C++ standard has changed to C++20 where available, which is the case on all known platforms from 2021 on; where it is not, C++17 is used if available, otherwise C++ is not supported, as before. Packages can request C++17 if essential. R 4.3.0 had made C++17 the default. This concerns only packages with C++ code: Interfacing C, C++ and Fortran.

The citation of R now provides a DOI, 10.32614/R.manuals, and the NEWS asks authors to update their bibliographies accordingly. citation() shows it, as the block does, and toBibtex() gives the entry with the doi field. The page Getting Help and Documentation shows how to cite R and packages.

Source: R documentation: citation

Source: R NEWS: Changes in R 4.6.0