Allocator Part of Type

[Eugene Wissner]

On Thursday, 15 March 2018 at 19:36:10 UTC, jmh530 wrote:
> I recall some talk Andrei did where he said it was a bad idea 
> to make the allocator part of the type.  However, the container 
> library in dlang-community(says it is backed with 
> std.experimental.allocator) contains allocator as part of the 
> type. Automem does too. Honestly, I would think you would 
> really be hobbled if you didn't. For instance, if you want to 
> expand a DynamicArray using the built-in ~= operator, then you 
> really need to know what the allocator is. Without ~= you'd 
> have to rely on functions (maybe member functions, maybe not).
>
> So I suppose I'm wondering why is it a bad thing to include the 
> allocator as part of the type and why is it that it seems like 
> in practice that's how it is done anyway.

I think it is done in D, because it was always done in C++ this 
way, so it is known to be a working solution.

I see two reasons to make the allocators part of the type
1. Virtual function calls are slow, so let us do all allocators 
to structs and then we can pass them as a part of the type 
without using stuff like IAllocator, allocatorObject etc.
2. Used allocator is actually known at compile-time, so it can be 
decided at compile-time what allocator to use.

Now there are Bloomberg Labs allocators for C++ [1] (or BDE 
allocators), that are polymorphic allocators, so the allocators 
just implement an interface. The main reasoning behind it was as 
far as I remember to reduce compile time (and Bloomberg has tons 
of C++ code), so they developed these allocators and containers 
that accept the allocator as constructor argument and save it as 
a container member.

The main problem with allocators as part of the type isn't that 
you can't compare or assign types with different allocators - 
with a bit metaprogramming it is easy. The problem for me is that 
all you code should be templated then. You can't have a function

"void myFunc(Array!int)"

because it would work only with one allocator if the allocator is 
part of the type.

So I'm using polymorphic allocators for a long time [2].

I'm surprised to see that std.experimental.allocator 
documentation includes now an example how to save "the IAllocator 
Reference For Later Use".

[1] https://github.com/bloomberg/bde/wiki/BDE-Allocator-model
[2] 
https://github.com/caraus-ecms/tanya/blob/80a177179d271b6d023f51aa3abb69376415b36e/source/tanya/container/array.d#L205