Why do std::optional constructors use std::in_place?

Question

Some std::optional constructors use an std::in_place_t tag parameter like this:

template< class... Args > 
explicit optional( std::in_place_t, Args&&... args );

I see that such constructors could be implemented without the in-place tag and use some enable_if (SFINAE) magic to not participate as unwilling overloads, i.e.:

template< class... Args > 
explicit optional( Args&&... args );

Why are std::optional’s in-place constructors implemented with an std::in_place_t tag rather than with some enable_if magic (and no tag)?

Update: Question is slightly updated to emphasize that I realize that simply omitting the in-place tag wouldn’t work.

Answer 1

As Passer By said in the comment, the intent is to disambiguate the situation where one wants to call the default constructor of optional<T> and the situation where one wants to call the default constructor of T.

This intention is proposed in N3527, where the original proposed name of in_place_t is emplace. I quote the related part here:

We need the extra tag to disambiguate certain situations, like calling optional's default constructor and requesting T's default construction:

optional<Big> ob{emplace, "1"}; // calls Big{"1"} in place (no moving)
optional<Big> oc{emplace};      // calls Big{} in place (no moving)
optional<Big> od{};             // creates a disengaged optional