Don't bother using the container
framework if speed is of high importance. An exception is the dict.table
class, which is very fast as it is based on data.table. Other than that, if computation speed is critical for your application, we refer you to using base R list or packages that were optimized for performance, such as the collections package.
Consider using the container
framework over base list
if you are looking for ...
Furthermore consider using dict.table
for a flexible and robust way to manage data columns of data.table
s.
In an interactive R session a container
can be used similar to a base R list
, but also provides some extra features. For easier typing it's recommended to use the shorter cont
.
library(container)
co = cont(a = 1, b = 1:10) # same as co = container(a = 1, b = 1:10)
The container print method is designed to be very compact.
print(co)
# [a = 1, b = (1L 2L 3L 4L ...)]
For more verbose output, either convert to a base list
...
as.list(co)
# $a
# [1] 1
#
# $b
# [1] 1 2 3 4 5 6 7 8 9 10
or use str
.
str(co)
# Container of 2
# $ a: num 1
# $ b: int [1:10] 1 2 3 4 5 6 7 8 9 10
Both length
and names
work as usual.
length(co)
# [1] 2
names(co)
# [1] "a" "b"
names(co)[1] <- "A"
co
# [A = 1, b = (1L 2L 3L 4L ...)]
A container can also be constructed from a list.
l = list(x = (1:2)^1, y = (1:2)^2)
co2 = as.container(l)
co2
# [x = (1 2), y = (1 4)]
Elements can be added by concatenation,
c(co, co2)
# [A = 1, b = (1L 2L 3L 4L ...), x = (1 2), y = (1 4)]
or name,
co[["c"]] <- 3
co
# [A = 1, b = (1L 2L 3L 4L ...), c = 3]
and containers can be nested.
co[["co2"]] <- co2
co
# [A = 1, b = (1L 2L 3L 4L ...), c = 3, co2 = [x = (1 2), y = (1 4)]]
In contrast to base R list
, elements cannot be added via positional index if it exceeds the container's length.
co[[5]] <- 5
# Error: index out of range (length = 4): 5
Single or multiple value replacement works as usual.
co[[3]] <- 0
co[1:2] <- 0
co
# [A = 0, b = 0, c = 0, co2 = [x = (1 2), y = (1 4)]]
In contrast to base list
, containers can take a mix of numeric and character indices.
co[list("A", 2, "c")] <- list(1, 2, "three")
co
# [A = 1, b = 2, c = "three", co2 = [x = (1 2), y = (1 4)]]
Another option for container object is to replace by value.
co[[{"three"}]] <- 3
co
# [A = 1, b = 2, c = 3, co2 = [x = (1 2), y = (1 4)]]
This works for any data type.
co[[{co2}]] <- 3
co
# [A = 1, b = 2, c = 3, co2 = 3]
The standard operators to access elements also should be familiar to R users. 1
co[[1]]
# [1] 1
co[1:3]
# [A = 1, b = 2, c = 3]
As another option, you can pass any number of indices, possibly mixed as numeric and character.
co[1, 3, "b"]
# [A = 1, c = 3, b = 2]
co[2:1, "A"]
# [b = 2, A = 1, A = 1]
Invalid indices don't produce NULL
s but are just ignored.
co[1:100]
# [A = 1, b = 2, c = 3, co2 = 3]
Count the number of elements.
count(co, 1)
# [1] 1
count(co, 3)
# [1] 2
Use the apply family.
sapply(co, is.numeric)
# A b c co2
# TRUE TRUE TRUE TRUE
sapply(co, function(x) x + 1)
# A b c co2
# 2 3 4 4
Next, see vignette Container operations for robust code.
Note that the $
operator does not work.↩