The hardware and bandwidth for this mirror is donated by METANET, the Webhosting and Full Service-Cloud Provider.
If you wish to report a bug, or if you are interested in having us mirror your free-software or open-source project, please feel free to contact us at mirror[@]metanet.ch.
Since R has always been used as an interactive tool, base R list operations are generous with respect to errors, which can lead to undetected bugs when developing code. In contrast, the container package provides additional functions for all basic operations that allow for fine control to avoid many pitfalls that can happen with lists and will usually result in more robust code.
New elements can be added "as usual" by concatenation or name.
co <- container()
co[["x"]] <- 1
co <- c(co, 2)
co
# [x = 1, 2]In addition, the container package provides add, which allows to add new elements by name even if that name exists already.
co = add(co, x = 3) # same as c(co, container(x = 3))
co
# [x = 1, 2, x = 3]Basic replacement again can be done "as usual" by name or position.
co[["x"]] <- 0
co[[2]] <- 12
co
# [x = 0, 12, x = 3]In contrast to base lists, the container will not allow to add elements at positions longer than the length of the object.
co[[4]] <- 4
# Error: index out of range (length = 3): 4If the name does not exist, the element is appended as known from base lists.
co[["y"]] <- 4
co
# [x = 0, 12, x = 3, y = 4]If you want to make sure that something is replaced, container provides the function replace_at, which will only replace elements if at names or positions that exist. The following statements are all equal and show the different possibilities on how to use replace_at.
replace_at(co, x = 10, y = 13) # name = value pairs
# [x = 10, 12, x = 3, y = 13]
replace_at(co, c("x", "y"), c(10, 13)) # names followed by values
# [x = 10, 12, x = 3, y = 13]
replace_at(co, c(1, 4), c(10, 13)) # positions followed by values
# [x = 10, 12, x = 3, y = 13]
replace_at(co, list(1, "y"), c(10, 13)) # mixed names/positions followed by values
# [x = 10, 12, x = 3, y = 13]Now see how invalid indices are signaled.
replace_at(co, z = 10)
# Error: names(s) not found: 'z'
replace_at(co, "z", 10)
# Error: names(s) not found: 'z'
replace_at(co, 5, 10)
# Error: index out of range (length = 4): 5If you instead want elements at new names to be added, set .add = TRUE. Invalid positional indices are still signaled.
co = replace_at(co, z = 10, .add = TRUE)
co = replace_at(co, 7, 10, .add = TRUE)
# Error: index out of range (length = 5): 7
co
# [x = 0, 12, x = 3, y = 4, z = 10]It is also possible to replace elements by value, that is, you specify the value (not the index) that should be replaced. Let's replace the 12 by "foo" and then 4 by 1:4.
co = replace(co, 12, "foo")
co
# [x = 0, "foo", x = 3, y = 4, z = 10]
co = replace(co, 4, 1:4)
co
# [x = 0, "foo", x = 3, y = (1L 2L 3L 4L), z = 10]In an interactive R session you may want to apply the notation using curly braces.
co[[{1:4}]] <- 1:2
co
# [x = 0, "foo", x = 3, y = (1L 2L), z = 10]First of all, standard extract operators apply as expected.
co[[1]]
# [1] 0
co[["x"]]
# [1] 0
co[3:5]
# [x = 3, y = (1L 2L), z = 10]
co[c("x", "y", "z")]
# [x = 0, y = (1L 2L), z = 10]Programmatically, the corresponding functions to select one or multiple elements are named at2 and at.
at2(co, 1)
# [1] 0
at2(co, "x")
# [1] 0
at(co, 3:5)
# [x = 3, y = (1L 2L), z = 10]
at(co, c("x", "y", "z"))
# [x = 0, y = (1L 2L), z = 10]As before you can specify mixed indices via lists.
indices = list("x", 4, "z")
at(co, indices)
# [x = 0, y = (1L 2L), z = 10]Again, accessing non-existent names or positions is signaled with an error.
at2(co, 10)
# Error: index 10 exceeds length of Container, which is 5
at2(co, "a")
# Error: index 'a' not found
at(co, 3:6)
# Error: index 6 exceeds length of Container, which is 5
at(co, c("x", "a"))
# Error: index 'a' not foundWith base R lists non-existent indices usually yield NULL.
l = list()
l[["a"]]
# NULL
l[2:3]
# [[1]]
# NULL
#
# [[2]]
# NULLIf needed, the (less strict) list access can be mimicked with peek_at and peek_at2.
peek_at2(co, "a")
# NULL
peek_at(co, 10, 11)
# []
peek_at(co, 5:10)
# [z = 10]As you see, one important difference is multiple access via peek_at will not insert NULL values by default. However, both functions in fact allow to specify the default value that is returned if the index does not exist.
peek_at2(co, "a", default = -1)
# [1] -1
peek_at(co, "z", "a", .default = -1)
# [z = 10, a = -1]
peek_at(co, 4:8, .default = NA)
# [y = (1L 2L), z = 10, NA, NA, NA]To remove elements in lists, they have to be replaced by NULL.
l = list(a = 1)
l
# $a
# [1] 1
l[["a"]] <- NULL
l
# named list()With the container package this is done differently, as replacing by NULL will not delete the element but literally replace it by NULL.
co[["x"]] <- NULL
co
# [x = NULL, "foo", x = 3, y = (1L 2L), z = 10]Instead, elements can be deleted by index (delete_at) or value (delete) as follows.
delete_at(co, 1, "y", "z")
# ["foo", x = 3]
delete(co, NULL, 1:2, 10) # same but remove by value
# ["foo", x = 3]As before, invalid indices or missing values are signaled.
delete_at(co, "a")
# Error: names(s) not found: 'a'
delete_at(co, 10)
# Error: index out of range (length = 5): 10
delete(co, 1:3)
# Error: (1L 2L 3L) is not in ContainerIf you need a less strict delete operation, use the discard functions, which delete all valid indices/values and ignore the rest.
discard_at(co, 1, "a")
# ["foo", x = 3, y = (1L 2L), z = 10]
discard_at(co, 1:100)
# []
discard(co, NULL, 1:2, 1:3, 1:4)
# ["foo", x = 3, z = 10]The update function is used to combine/merge two containers.
c1 = container(1, b = 2)
c2 = container( b = 0, c = 3)
update(c1, c2)
# [1, b = 0, c = 3]
update(c2, c1)
# [b = 2, c = 3, 1]With the container package this function is also provided for base R lists.
l1 = list(1, b = 2)
l2 = list( b = 0, c = 3)
update(l1, l2)
# [[1]]
# [1] 1
#
# $b
# [1] 0
#
# $c
# [1] 3
update(l2, l1)
# $b
# [1] 2
#
# $c
# [1] 3
#
# [[3]]
# [1] 1These binaries (installable software) and packages are in development.
They may not be fully stable and should be used with caution. We make no claims about them.