About conversion between different "any" types, I've found a note in the docs that says it's possible. Disregard the question in my previous email. Some more thoughts: 1. In the docs, "Functions with Multiple Arguments", it is said that the underlying types of the two "any" arguments must match or the behavior is undefined. I assume this is due to the fact that the type_id_ concept is optional and the implementation doesn't really know the underlying types of the "any" values and simply assumes they match. I think this is a too dagerous assumption and some basic check must always be performed. Probably, the underlying type information must always be stored in one way or another and verified when needed. Maybe, the type_id_ concept must be mandatory even. 2. In the same section, I didn't really understand the second code snippet. Why is the tuple needed? Why not this: any<requirements, _a> a = &array[0]; a = a + 2; Also, from the implementation perspective, will it simply add 2 to the pointer or construct an "any" from 2 and then perform the addition? 3. Are there plans to make the underlying value storage customizable? It would be great if "any" supported small object optimization or custom memory allocators. 4. How can I test if an "any" instance is null? I assume that I cannot compare the instance with a default-constructed "any" because this would result in attempt to compare stored values. 5. The "Why do I have to specify the presence of a destructor explicitly?" rationale doesn't seem like a good enough reason. The code already has a specialization for references, and it is natural that references are stored as a pointer to the external value (I really hope there are no dynamic memory allocations performed in this case). So for references, there is no need to call a destructor of the object at all. On the other hand, I can't imagine an "any" with an object by value which cannot be destructed.