There is no way to remove a key–value pair and extract the value with one lookup. One has to make one lookup to get the value (if any), and another to remove the pair.

Currently, the `remove` function returns a `bool` value indicating via `true` that a key–value pair with the passed `key` was present, and `false` when it was not.

This could be improved by instead returning a pointer to the value if they pair existed, and `null` otherwise, i.e. exactly what `in` does, but additionally removing the value.

With this enhancement, extract–remove is a trivial one-liner.
Compare this:
```d
Value* v = key in aa;
aa.remove(key);
if (v != null)
{
    // handle the value
    // *v is valid even after removal.
}
```
with this:
```d
if (Value* v = aa.remove(key))
{
    // handle the value
}
```

There should be minimal breakage because most current uses of `remove` will ignore its result anyways, and if not, the returned pointer converts to `true` implicitly if it is not `null` and `null` to `false` in contexts where a `bool` is required.

If that breakage cannot be tolerated or the new implementation is deemed considerably more expensive than current `remove`, I suggest a new function by the name `removeAndExtract` or (cf. Scott Mayers: `takeOut`).