Re: Will value semantics make C++ die?

I still think the way std::optional mixes value- and pointer semantics
is too confusing. I'd prefer if it was either value semantics /or/
pointer semantics. If it's going to be in C++14 I'd prefer pointer
semantics, otherwise I'd prefer value semantics. I'll explain.

In their paper there's one thing that I like a lot. They say that the
conceptual model for optional<T> is "A discriminated union of types
nullopt_t and T". But I wonder; why can't we make it even more generic
and make it more mathematical?

My proposal is to separate the two concerns into:

1. Using the T in std::optional
2. Checking for nullopt_t in std::optional

In Section 7.6 - "Using tag nullopt for indicating disengaged state",
Cacciola and Krzemienski say there are several components that could
benefit from supporting a nullopt tag. However, they also say that it's
outside of the scope of their proposal, but in my opinion the nullopt
perspective is more interesting than the std::optional itself.

I suggest to focus on concern 2 and rename nullopt to a more generic
name like emptyset.
http://en.wikipedia.org/wiki/Empty_set

The emptyset would not belong only to std::optional but could be used by
any kind of component that needs to express a missing value. Along with
emptyset I propose a new operator that returns false if a variable is
the emptyset. The operator could look like the following to look similar
to a mathematical set:

if( {ch} ) { // ... }

or, to look more similar to the range-based for loop:

if( ch: ) { // ... }

but none of them would probably work with existing language features so
for now you have to imagine some clean operator that returns false or
true if it's emptyset or not.

Having this operator we wouldn't need to mess up std::optional and
similar components with type conversion to bool to check engaged state,
but instead use a standardized operator related to emptyset.

Once we have acknowledged the empty set as its own type, we start
setting up mathematical rules for it similar to what Cacciola and
Krzemienski did but more extensive with +, -, *, / etc.

Correct me if I'm wrong, but having the emptyset in place, we wouldn't
need the observers in std::optional that now would use only value semantics.
http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3527.html#optional.object.observe

Here's a code example. In main(), pretend the E for Exist doesn't exist.

#include <iostream>

struct emptyset_t {} emptyset;

template<typename T>
const T& operator+( const emptyset_t&, const T& t )
{
   return t;
}

struct E
{
   template<typename T>
   E( const T& ) : exists_(true) {}
   E( emptyset_t ) : exists_(false) {}
   E() : exists_(false) {}

   operator bool() { return exists_; }

   bool exists_;
};

char nextChar()
{
   return 'Q';
}

int main()
{
   float a;
   emptyset_t b;
   char ch;

   if( E{ a = 3.14 } )
      std::cout << "1:st Exists: " << a << std::endl;
   else
      std::cout << "1:st is Empty Set" << std::endl;

   if( E{ b } )
      std::cout << "2:nd Exists" << std::endl;
   else
      std::cout << "2:nd is Empty Set" << std::endl;

   if( E{ b + 5 } )
      std::cout << "3:rd Exists" << std::endl;
   else
      std::cout << "3:rd is Empty Set" << std::endl;

   if( E{} )
      std::cout << "4:th Exists" << std::endl;
   else
      std::cout << "4:th is Empty Set" << std::endl;

   if( E{ ch = nextChar() } )
      std::cout << "5:th Exists: " << ch << std::endl;
   else
      std::cout << "5:th is Empty Set" << std::endl;

   return 0;
}

What do you think if this approach to make std::optional a success?

Regards,
Daniel

--
      [ See http://www.gotw.ca/resources/clcm.htm for info about ]
      [ comp.lang.c++.moderated. First time posters: Do this! ]