merge_recursive on Vector of Pairs

[Lincoln-Hannah]

Would you consider adding something like this ?

using Underscores, Lazy, NamedTupleTools

NamedTupleTools.namedtuple(x::Pair)                                     = namedtuple([x])
NamedTupleTools.merge_recursive(x::Vector)                              = merge_recursive(x...)
NamedTupleTools.merge_recursive(x::Matrix)                              = merge_recursive(x...)
NamedTupleTools.merge_recursive(x::Vector{Pair{Symbol,T}}) where T<:Any = merge_recursive(merge_recursive.(x))
NamedTupleTools.merge_recursive(x::Matrix{Pair{Symbol,T}}) where T<:Any = merge_recursive(merge_recursive.(x))
NamedTupleTools.merge_recursive(   (a,b)::Pair{Symbol,T} ) where T<:Any = namedtuple( a=> merge_recursive(b) )
NamedTupleTools.merge_recursive( x::Any )                               = x

simple use case merge_recursive([:a=> [:a2=>2],:b=>2,:c=>10,:d=> [:x => 20], :d=>[:y=> 10] , :a=>[:a1=>1] ] )

Actual use case: Creating nested named tuple of DB connections so I can specify a connection as Connections.Prod.DB1
Currently writing like this

Servers = [:Prod; :Dev]
DBs     = [:DB1 :DB2 :DB3]
conLogic(Server,DB) = "$Server $DB"  #would actually be ODBC... try connect ... 


Connect(Server,DB)  = namedtuple( [Server => namedtuple([DB => conLogic(Server,DB) ] ) ])
Connections         = @_@>  Connect.( Servers, DBs )  merge_recursive(_...)

The above would allow the last two lines to be

Connect(Server,DB)  = Server => [DB => conLogic(Server,DB)]
Connections         = @>  Connect.( Servers, DBs )     merge_recursive

[JeffreySarnoff]

The requirements (Underscores, Lazy) are the only reason to hesitate.

[Lincoln-Hannah]

Sorry, the dependencies were only for the examples. The proposed package code is just this

namedtuple(x::Pair)                                     = namedtuple([x])
merge_recursive(x::Vector)                              = merge_recursive(x...)
merge_recursive(x::Matrix)                              = merge_recursive(x...)
merge_recursive(x::Vector{Pair{Symbol,T}}) where T<:Any = merge_recursive(merge_recursive.(x))
merge_recursive(x::Matrix{Pair{Symbol,T}}) where T<:Any = merge_recursive(merge_recursive.(x))
merge_recursive(   (a,b)::Pair{Symbol,T} ) where T<:Any = namedtuple( a=> merge_recursive(b) )
merge_recursive( x::Any )                               = x