Associative arrays, multithreading, Rebindable

[Jack Applegame]

If I want to pass a dynamic array from one thread to another, 
then I use immutable(T)[] and it is safe.
But what if I need to pass an associative array? I suppose that 
the use of immutable(T)[U] is unsafe. Because one thread can 
delete the entry and this will have an impact also on the 
instance of the array in another thread.
So I have to use immutable(T[U]). But the immutability of the 
entire array makes the array reference immutable too:

immutable int[string] foo;
foo = assumeUnique(other); // error

For immutable classes we can use std.typecons.Rebindable:

Rebindable!(immutable Foo) foo;
foo = new immutable Foo; // fine

But for immutable associative arrays we can't:

Rebindable!(immutable int[string]) foo; // error
foo = assumeUnique(other);

Error: template instance 
std.typecons.Rebindable!(immutable(int[string])) does not match 
template declaration Rebindable(T) if (is(T == class) || is(T == 
interface) || isArray!T)

Should Rebindable to support associative arrays?