R Lists Exercises: 20 Subsetting, Iteration and Nesting Problems

Explanation: Unlike an atomic vector, a list does not coerce its elements to a common type, so a string, a number, a character vector and a logical can coexist as siblings. Names are optional but make $ access possible; without them you must use positional indexing. A common mistake is wrapping the values in c(), which would coerce them all to character.

Explanation: length() on a list returns the count of top-level elements only, never the total atoms inside. names() returns NULL if no names were set, which is a useful guard for defensive code. sapply(x, class) simplifies to a named character vector here because every element returns a length-one string. For a one-shot human-readable view, str(ex_1_1) is the idiomatic alternative.

Explanation: Growing a list with $ assignment is O(n) per write in R because each assignment copies the list, so for large loops you should pre-allocate with vector("list", n) and write to out[[i]]. For small fixed structures like this one the readability is worth more than the speed. Note that ex_1_3[["alpha"]] <- 1:3 is equivalent to ex_1_3$alpha <- 1:3.

Explanation: Indexing with a character vector reorders and selects in one step, which is the cleanest pattern when you want both. setNames() is a wrapper around names(x) <- value that returns the renamed object, so it composes well inside a pipeline. If you only want to rename without reordering, names(raw) <- toupper(names(raw)) is more direct. Position-based reordering would use a numeric index instead.

Explanation: Single bracket [ always preserves the container type, so indexing a list with [ returns a (shorter) list. Double bracket [[ strips one level of nesting and returns the element itself, so box[["fruit"]] gives the character vector. This distinction is the single most common source of bugs when reading model output: lm_fit["coefficients"] is a list of length one, but lm_fit[["coefficients"]] is the named numeric vector you actually want.

Explanation: A character vector inside single brackets selects multiple elements and preserves their list structure, which is the right behaviour when you want to pass a clean subset onward. [[ cannot take a multi-element vector of names in this way, so for any selection of size two or more you must use [. Negative indexing by name is not supported; to exclude fields use setdiff() on the names first.

Explanation: $name is non-standard evaluation: R looks up the literal symbol target as an element name, finds none, and returns NULL silently rather than erroring. [[var]] is standard evaluation, so it evaluates target to "rmse" first and then looks up that key. The silent NULL from $ is a frequent source of bugs when refactoring hard-coded names into variables, which is why functions that accept user-specified column names always use [[ internally.

Explanation: [[ accepts a vector of indices or names and walks the structure level by level, so tree[[c("a", "b", "c")]] is shorthand for tree[["a"]][["b"]][["c"]]. This recursive form is concise but throws if any intermediate level is missing, unlike the explicit chain which would fail at the same point with a clearer message. The mixed form tree[[c("a", "b")]][["c"]] is also valid when only part of the path is known up front.

Explanation: [[<- replaces the element identified by the index or name with the new value, preserving the rest of the list. Using $port <- 6543L produces the same outcome and is more idiomatic when the name is a literal. Beware: cfg["port"] <- list(6543L) also works but requires wrapping the value in list() because [<- expects a list on the right-hand side; this is a frequent source of confusion.

Explanation: Assigning NULL to a list element via [[ deletes it from the structure entirely; the length drops by one. To set an element to a literal NULL value without deletion you must wrap it: cfg["debug"] <- list(NULL). This asymmetry trips up users coming from Python dicts, where cfg["debug"] = None keeps the key. To delete multiple keys at once, use cfg[c("debug", "ssl")] <- NULL.

Explanation: modifyList() is the right tool for layered defaults plus overrides, the same pattern you see in YAML or JSON config merging. It recurses into nested lists by default, so a deeply nested override only touches the inner keys you change, not the whole branch. The simpler alternative c(base, patch) would also work for appending but would produce duplicate names rather than overriding, which usually is not what you want.

Explanation: lapply(X, FUN) always returns a list of the same length as the input, one element per input element. Because every mean() call returns a length-one numeric, the result is a list of 11 scalars, named after the columns. The list shape is the right return type when individual results could vary in length or type; for the simpler case where they are all the same shape, sapply() collapses to a vector (covered next).

Explanation: sapply() calls lapply() then attempts to simplify: if every result is length one of the same type, it returns a named vector; if every result is the same longer length, it returns a matrix; otherwise it falls back to a list. The auto-simplification is convenient but type-unstable, which is why production code prefers vapply() (next exercise) where the return shape is declared up front and silent surprises are eliminated.

Explanation: vapply() requires you to declare the expected return template, which catches at runtime any iteration that returns the wrong type or length. If a column were accidentally character, mean() would return NA_real_ with a warning but the contract would still hold; if it returned a longer vector, vapply would error rather than reshape silently. Use vapply() over sapply() whenever the function might be applied to user data of uncertain shape.

Explanation: Map() is the multi-list version of lapply(): it iterates over all the lists in parallel and calls the function with one element from each, always returning a list. You can pass any binary function, including infix operators wrapped in backticks like ` * . For a vector return shape instead, wrap with mapply(..., SIMPLIFY = TRUE) or use mapply()` directly. Names are inherited from the first list argument.

Explanation: Nested lists are just lists whose elements are themselves lists, which is the natural shape for any hierarchical record like an order or a JSON object. Use str() to see the tree at a glance, and tree[["alice"]][["items"]] or tree[[c("alice", "items")]] to reach inner leaves. There is no limit on nesting depth, but flat structures are usually easier to query, so collapse to a data frame whenever the leaves are homogeneous.

Explanation: The anonymous lambda \(x) length(x$items) is the shortest way to reach into one field of each sublist. The shorthand \(x) for function(x) was added in R 4.1 and is now standard. The names are inherited from the outer list so the result is self-describing. If you needed multiple statistics per customer, replace the lambda with a function that returns a small named vector or list of summaries.

Explanation: unlist() recursively descends into a list and concatenates atomic leaves into one vector, coercing to the most general type as needed. The compound names come from joining the parent element name with the child index. Pass use.names = FALSE to drop the names, or recursive = FALSE to flatten only the top level. Beware that flattening a list of model objects coerces everything to character and is almost never what you want.

Explanation: rapply() (recursive apply) walks every leaf of a nested list and applies the function. With how = "replace" it preserves the tree shape; with how = "unlist" it returns a flat vector of results. The classes filter limits transformation to leaves of the named classes, so you can safely run a numeric transform on a mixed-type tree without touching strings or factors. This is the cleanest base-R way to normalise nested JSON-like structures.

Explanation: Filter() is a higher-order function that keeps elements for which the predicate returns TRUE. The predicate must return a single logical per element, which fits perfectly with the lambda shape here. The complement is Find(), which returns the first matching element rather than all of them, and Position(), which returns the index. Together these three functions cover the common base-R subset of stream filtering vocabulary.

Explanation: A data frame is internally a list of equal-length columns with a row.names attribute, so a column-oriented list with the right shape converts almost for free. The conversion fails loudly if the lengths do not match; partial recycling does not happen here. as_tibble(cols) from the tibble package is the modern equivalent and avoids the legacy stringsAsFactors behaviour, though that default flipped to FALSE in R 4.0.

Explanation: Row-oriented data is the natural output of web scrapers and JSON APIs, but R prefers column-oriented frames, so you must pivot. lapply converts each list-record to a one-row data frame, then do.call(rbind, .) stacks them. The do.call step is needed because rbind is variadic and you have to splat the list of frames into separate arguments. For large inputs the data.table or dplyr bind_rows equivalent is much faster, but the base recipe always works.

Explanation: Almost every lm, glm or nls model object is a structured list, which is why understanding lists pays off across the language. fit[["coefficients"]] returns the named numeric vector; the wrapper coef(fit) does the same and is the canonical accessor. Use names(fit) or str(fit, max.level = 1) to discover what is inside any new model class without reading docs.

Explanation: enframe() turns a named atomic vector into a two-column tibble (name, value), which is the cleanest format for plotting or joining named-list output. When the input is a list of scalars, unlist() first collapses it to a named numeric vector, then enframe builds the tibble. The inverse function is deframe(), which takes a two-column tibble back to a named vector, completing the round trip.