On 07/06/2015 09:10 AM, Larry Evans wrote:
On 06/28/2015 03:38 AM, Vicente J. Botet Escriba wrote:> Le 27/06/15 21:32, Agustín K-ballo Bergé a écrit : [snip]
I know that your variant is possibly empty and the C++ standard proposal is never-empty, and this makes them different from the user point of view. Bjarne S. and Anthony W. are pushing towards a possible empty variant, we don't know yet what the std::experimental::variant will be and less yet what std::variant will be in C++17.
boost::variant combined with boost::blanc gives this kind of possibly empty variant, but IMHO this is a quite different type.
template <class ...Ts> using optional_variant = boost::variant<boost::blanc, Ts...>; // +/-
I suggest to name them as variant<Ts...> : never-empty optionals<Ts...> : possibly empty
I believe that the usage of these classes is quite different.
There is something that I don't like of the possibly empty variant. It confounds the empty state and a hidden error state. When we assign a type A to variant containing a type B the resulting variant can be empty (contains a different type C).
The above example is unclear to me. Is this what you mean:
#include <assert.h> int main() { variant<B> vb; assert(is_empty(vb)); assert(!is_error(vb)); vb = B{}; assert(!is_empty(vb)); assert(!is_error(vb)); vb = A{} assert(is_empty(vb));//? assert(is_error(vb));//? return 0; }
where the is_empty and is_error return true if the variant is empty or in error, respectively. [snip]
Or maybe, in keeping with the Ternary Logic Programming branch of this thread: #include <assert.h> enum var_stat { var_error , var_empty , var_full } struct A{}; struct B{}; template<typename... Types> struct variant{...}; int main() { variant<V> vb; assert(status(vb) == var_empty); vb = B{}; assert(status(vb) == var_full); vb = A{}; assert(status(vb) == var_error); return 0; }