NestedTuples

NestedTuples has some tools for making it easier to work with nested tuples and nested named tuples.

Named tuples as contexts

We can do this with @with, similar to StaticModules.jl (and identical syntax):

julia> @with((x=1, y=2), x+y)
3

These can also be nested, with good performance:

julia> nt = (x=1, y=(a=2, b=3))
(x = 1, y = (a = 2, b = 3))

julia> @with nt begin
           x + @with y (a+b)
       end
6

julia> @btime @with $nt begin
              x + @with y (a + b)
              end
  0.010 ns (0 allocations: 0 bytes)
6

Note that we haven't yet done any rigorous comparison to StaticModules. The main reason for the alternative implementation is that we already have GeneralizedGenerated.jl as a dependency, and leveraging this makes the new implementation very simple.

Random nested tuples

randnt is useful for testing. Here's a random nested tuple with width 2 and depth 3:

julia> nt = randnt(2,3)
(w = (d = (p = :p, l = :l), e = (m = :m, v = :v)), q = (y = (r = :r, o = :o), g = (y = :y, h = :h)))

Schema

Does what it says on the tin:

julia> schema(nt)
(w = (d = (p = Symbol, l = Symbol), e = (m = Symbol, v = Symbol)), q = (y = (r = Symbol, o = Symbol), g = (y = Symbol, h = Symbol)))

schema is especially great for building generated functions on named tuples, because it works on types too:

julia> schema(typeof(nt))
(w = (d = (p = Symbol, l = Symbol), e = (m = Symbol, v = Symbol)), q = (y = (r = Symbol, o = Symbol), g = (y = Symbol, h = Symbol)))

Flatten

julia> flatten(nt)
(:p, :l, :m, :v, :r, :o, :y, :h)

Recursive map

julia> rmap(String, nt)
(w = (d = (p = "p", l = "l"), e = (m = "m", v = "v")), q = (y = (r = "r", o = "o"), g = (y = "y", h = "h")))

Recursively sort keys

Use keysort for this.

julia> @btime keysort($nt)
  0.020 ns (0 allocations: 0 bytes)
(q = (g = (h = :h, y = :y), y = (o = :o, r = :r)), w = (d = (l = :l, p = :p), e = (m = :m, v = :v)))

Lazy Merge

Recursively merging named tuples can be expensive. lazymerge(nt1, nt2) creates a LazyMerge struct that behaves in the same way but can be much faster.

Leaf setter

leaf_setter takes a nested named tuple and builds a function that sets the values on the leaves.

julia> f = leaf_setter(nt)
function = (##777, ##778, ##779, ##780, ##781, ##782, ##783, ##784;) -> begin
    begin
        (w = (d = (p = var"##777", l = var"##778"), e = (m = var"##779", v = var"##780")), q = (y = (r = var"##781", o = var"##782"), g = (y = var"##783", h = var"##784")))
    end
end

julia> @btime $f(1:8...)
  0.020 ns (0 allocations: 0 bytes)
(w = (d = (p = 1, l = 2), e = (m = 3, v = 4)), q = (y = (r = 5, o = 6), g = (y = 7, h = 8)))

Fold

fold is a "structural fold". You give it a function f, and the result will apply f at the leaves, and then combine leaves recursively also using f. It also allows an optional third argument as a pre function to be applied on the way down to the leaves. This is probably clearer from an example:

function example_fold(x) 
    pathsize = 10
    function pre(x, path)
        print("↓ path = ")
        print(rpad(path, pathsize))
        println("value = ", x)
        return x
    end 

    function f(x::Union{Tuple, NamedTuple}, path)
        print("↑ path = ")
        print(rpad(path, pathsize))
        println("value = ", x)
        return x
    end 

    function f(x, path)
        print("↑ path = ")
        print(rpad(path, pathsize))
        print("value = ", x)
        println(" ←-- LEAF")
        return x
    end 

    fold(f, x, pre)
end

julia> example_fold(nt)
↓ path = ()        value = (w = (d = (p = :p, l = :l), e = (m = :m, v = :v)), q = (y = (r = :r, o = :o), g = (y = :y, h = :h)))
↓ path = (:w,)     value = (d = (p = :p, l = :l), e = (m = :m, v = :v))
↓ path = (:w, :d)  value = (p = :p, l = :l)
↓ path = (:w, :d, :p)value = p
↑ path = (:w, :d, :p)value = p ←-- LEAF
↓ path = (:w, :d, :l)value = l
↑ path = (:w, :d, :l)value = l ←-- LEAF
↑ path = (:w, :d)  value = (p = :p, l = :l)
↓ path = (:w, :e)  value = (m = :m, v = :v)
↓ path = (:w, :e, :m)value = m
↑ path = (:w, :e, :m)value = m ←-- LEAF
↓ path = (:w, :e, :v)value = v
↑ path = (:w, :e, :v)value = v ←-- LEAF
↑ path = (:w, :e)  value = (m = :m, v = :v)
↑ path = (:w,)     value = (d = (p = :p, l = :l), e = (m = :m, v = :v))
↓ path = (:q,)     value = (y = (r = :r, o = :o), g = (y = :y, h = :h))
↓ path = (:q, :y)  value = (r = :r, o = :o)
↓ path = (:q, :y, :r)value = r
↑ path = (:q, :y, :r)value = r ←-- LEAF
↓ path = (:q, :y, :o)value = o
↑ path = (:q, :y, :o)value = o ←-- LEAF
↑ path = (:q, :y)  value = (r = :r, o = :o)
↓ path = (:q, :g)  value = (y = :y, h = :h)
↓ path = (:q, :g, :y)value = y
↑ path = (:q, :g, :y)value = y ←-- LEAF
↓ path = (:q, :g, :h)value = h
↑ path = (:q, :g, :h)value = h ←-- LEAF
↑ path = (:q, :g)  value = (y = :y, h = :h)
↑ path = (:q,)     value = (y = (r = :r, o = :o), g = (y = :y, h = :h))
↑ path = ()        value = (w = (d = (p = :p, l = :l), e = (m = :m, v = :v)), q = (y = (r = :r, o = :o), g = (y = :y, h = :h)))
(w = (d = (p = :p, l = :l), e = (m = :m, v = :v)), q = (y = (r = :r, o = :o), g = (y = :y, h = :h)))