is there a merge for associative arrays

[Daniel Davidson]

On Tuesday, 5 November 2013 at 17:47:16 UTC, bearophile wrote:
> TV[TK] mergeAAs(TK, TV)(TV[TK] aas...) {
>
> It seems even fit for Phobos.
>
> Bye,
> bearophile

I have something I would appreciate feedback/criticism on. My 
first stab at it worked, but had no support for passing in 
const/immutable.

AA mergeAAs(alias fun = "a + b", AA)(AA[] aas...) 
if(isAssociativeArray!AA) {
   AA result;
   ...
}

Not sure if this is a good way or if there are better idiomatic 
ways, but here is what I have got. Any suggestions/improvements 
to make it more idiomatic would be appreciated. Is there already 
a DeepUnqual equivalent in phobos?

Thanks
Dan

import std.stdio;
import std.traits;
import std.algorithm;
import std.functional;

template DeepUnqual(T) {
   static if(isAssociativeArray!T) {
     alias Unqual!(Unqual!(ValueType!T)[Unqual!(KeyType!T)]) 
DeepUnqual;
   } else static if(isDynamicArray!T) {
     alias Unqual!(Unqual!(ArrayElementType!T)[]) DeepUnqual;
   } else static if(isPointer!T) {
     alias Unqual!(PointerTarget!T) * DeepUnqual;
   } else {
     alias Unqual!T DeepUnqual;
   }
}

DeepUnqual!AA
mergeAAs(alias fun = "a + b", AA)(AA[] aas...) 
if(isAssociativeArray!AA) {
   DeepUnqual!AA result;
   if(aas.length) {
     foreach( aa ; aas ) {
       foreach( k , v ; aa ) {
         auto found = k in result;
         if(found) {
           *found = binaryFun!fun(*found, v);
         } else {
           result[k] = v;
         }
       }
     }
   }
   return result;
}

void main() {
   alias double[string] AA;
   AA a = [ "foo":1.1, "bar":2.2 ];
   AA b = [ "foo":1.1, "bard":2.2 ];
   writeln(mergeAAs(a, b));
   writeln(mergeAAs!q{a*b}(a, b));

   {
     const AA ca = a.dup;
     const AA cb = b.dup;
     writeln(mergeAAs(ca,cb));
   }

   {
     immutable AA ia = [ "foo":1.1, "bar":2.2 ];
     immutable AA ib = [ "foo":1.1, "bard":2.2 ];
     writeln(mergeAAs(ia,ib));
   }
}