are-bare-type-predicates: Bare type predicates

Description

Wrappers around rlang type predicates that allow multiple objects to be passed. The following documentation is adapted from the rlang documentation:

These predicates check for a given type but only return TRUE for bare R objects. Bare objects have no class attributes. For example, a data frame is a list, but not a bare list.

The predicates for vectors include the .n argument for pattern-matching on the vector length.
Like are_atomic() and unlike base R is.atomic() for R < 4.4.0, are_bare_atomic() does not return TRUE for NULL. Starting in R 4.4.0, is.atomic(NULL) returns FALSE.
Unlike base R is.numeric(), are_bare_double() only returns TRUE for floating point numbers.

Usage

are_bare_list(..., .n = NULL, .all = FALSE)
are_bare_atomic(..., .n = NULL, .all = FALSE)
are_bare_vector(..., .n = NULL, .all = FALSE)
are_bare_integer(..., .n = NULL, .all = FALSE)
are_bare_double(..., .n = NULL, .all = FALSE)
are_bare_complex(..., .n = NULL, .all = FALSE)
are_bare_character(..., .n = NULL, .all = FALSE)
are_bare_string(..., .n = NULL, .all = FALSE)
are_bare_logical(..., .n = NULL, .all = FALSE)
are_bare_raw(..., .n = NULL, .all = FALSE)
are_bare_bytes(..., .n = NULL, .all = FALSE)
are_bare_numeric(..., .n = NULL, .all = FALSE)

Value

Named logical, or unnamed boolean if .all is TRUE.

Arguments

...: Objects to be tested.
.n: Expected lengths of the vectors.
.all: Whether to return if all arguments are TRUE.

Details

The optional input of .n can be given values that map to the arguments in .... If a unnamed vector/list, the input must either be the same length as the number of arguments given to ..., or length 1: which is then recycled to the number number of arguments given to .... Alternatively, a named vector/list can be given, where the values for matching named elements are passed to the type predicate, but unmatched names are passed NULL.

Examples

Run this code

x <- 1
y <- list()
class(y) <- c("my_class", class(y))
z <- mean

are_bare_list(x, y, z, list(1))

# `.all` can be given to test if all inputs
# evaluate to TRUE
are_bare_list(x, y, z, list(1), .all = TRUE)

# scalar inputs to `.n` are recycled to number of inputs
are_bare_list(x, y, z, list(1), .n = 2)

# inputs to `.n` matching the number of inputs
# are applied sequentially
are_bare_list(list(), y, list(1, 2, 3), list(1), .n = c(0, 0, 3, 1))

# named inputs to `.n` are applied to the matching input
# names, with the other inputs being given NULL
x <- list()
are_bare_list(x, y, list(1, 2, 3), list(1), .n = c(x = 5, "list(1)" = 2))