Mapping over trees

[lionel-]

at_bottom() would be like at_depth() but at bottom. Useful for tree structures.

[lionel-]

On that note I wonder if the following would be good UI:

array_tree(x, ~last)
array_tree(x, list(1, 2, ~last)

x %>% at_depth(~last, f)

[lionel-]

Other useful idiom for tree structures: visit each node twice. Once on the way in, the second time on the way back. See https://stlab.adobe.com/group__asl__tutorials__forest.html

The mapped function would get a boolean indicating if this is the second time we see the node.

[alistaire47]

Would this map over the deepest level or all leaf nodes? The latter (or some other intelligible version of rapply) could be really useful for parsing deeply nested data coming from JSON or the like.

[lionel-]

http://okmij.org/ftp/continuations/zipper.html

[lionel-]

@alistaire47 yes I was thinking at_bottom() would apply a function to leaves. We could have map_tree() to apply a function to all nodes, then at_bottom() would be implemented as:

x %>% map_tree_if(is_atomic, fn)

And maybe have map_tree_until(), which would not inspect further the nodes for which the predicate returns FALSE, which could be useful for applying a function to list-like S3 objects.

[hadley]

What if instead of at_bottom(.x, .f) you simply did at_depth(.x, -1, .f)?

And what if at_depth() was instead called modify_depth()? And to match the other modify() functions was called modify_depth()?

[hadley]

I also wonder about an option to at_depth() that gives you this behaviour:

  recurse <- function(x, depth) {
    if (depth > 1) {
      if (is.atomic(x)) {
        x
      } else {
        lapply(x, recurse, depth = depth - 1)
      }
    } else {
      lapply(x, .f, ...)
    }
  }

So that if the list is ragged, you can choose to only operate on lists at a certain level, ignoring branches that aren't that deep.