Boost logo

Boost :

Subject: Re: [boost] Adding polymorphic_value to boost
From: Tom (tomjordan766_at_[hidden])
Date: 2017-11-19 20:14:52

> Message: 10
> Date: Thu, 16 Nov 2017 02:14:30 -0700
> From: Jonathan Coe <jonathanbcoe_at_[hidden]>
> To: boost_at_[hidden]
> Cc: Matt Calabrese <calabrese_at_[hidden]>
> Subject: [boost] Adding polymorphic_value to boost
> Message-ID:
> <CAAbBDD9Ck+LhQ4iUraBtBkxexVKDt167qxyfTpDQqYM9bcMqLQ_at_[hidden]>
> Content-Type: text/plain; charset="UTF-8"
> I'd like to propose adding the class-template `polymorphic_value` to boost.
> `polymorphic_value` is designed to allow the compiler to correctly generate
> special member functions for classes with polymorphic components (It's
> `any` with an interface).
> `polymorphic_value` has been proposed for standardisation in P0201 and has
> advanced through the Library Evolution group in Albuquerque (Nov 5-10).
> A working draft of the proposal and implementation can be found at
> I gave a presentation about polymorphic_value at C++::London here:
> Matt Calabrese has kindly offered to be review manager.
> Kind regards,
> Jon
I'd be interested in such a utility. Mathias Gaunard proposed something
similar on the mailing list a long while ago, I implemented a simple
version myself based on that.
I have a small number of questions. Given that this is a value type,
does the current approach over-expose pointer (ownership) in the
interface (in essence it still appears to be a glorified smart pointer)
and understate its more fundamental purpose as a regular value with
dynamic type? There might be other things which can usefully be added
for such a value type, for example permitting direct construction of an
object of specific (derived) type, by passing the type as well as the
arguments for the constructor of that type (or wrapping the arguments in
some kind of in-place factory with explicit type). Something like:

// Simple wrapper to enable a static type to be passed through a
forwarding constructor.
template <typename T>
struct Type {};

// Forwarding constructor - actual type is deduced from type wrapped in
(unnamed) first argument's type
template <typename D, typename... Args>
explicit poly_obj(Type<D>, Args&&... args);

// Also could have an emplace member function
template <typename D, typename... Args>
void emplace(Type<D>, Args&&... args);

In theory you wouldn't need to expose pointers in the interface at all?
In fact, should a type-erasure library be preferred (e.g.,
Boost.TypeErasure or Adobe.Poly) as it provides a more general solution
for manipulating polymorphic value types (though typically harder to use)?
Would you be considering supporting C++98 via using the boost::move library?


Boost list run by bdawes at, gregod at, cpdaniel at, john at