Seamlessly migrating <experimental/optional> to <optional>

Question

From this Stack Overflow answer, I learned that C++17 will have __has_include, which can

[make] migrating from experimental to std almost seamless

This still leaves the question of how to do it. Doing something like namespace std { using namespace std::experimental; } is undefined behaviour, so I came up with this method:

optional.h ^{demonstration on coliru}

#pragma once

#if __has_include(<optional>)
#   include <optional>
#   define HAS_STD_OPTIONAL
#elif __has_include(<experimental/optional>)
#   include <experimental/optional>
#   define HAS_STD_EXPERIMENTAL_OPTIONAL
#else
#   error Must have an optional type, either from <optional> or if not supported from <experimental/optional>.
#endif

#if defined HAS_STD_OPTIONAL

namespace opt {
    template<class T>
    using optional = std::optional<T>;
    using bad_optional_access = std::bad_optional_access;
    using nullopt_t = std::nullopt_t;
    using in_place_t = std::in_place_t;

    constexpr auto nullopt = std::nullopt;
    constexpr auto in_place = std::in_place;

    template<class T>
    constexpr auto make_optional(T && value)
    {
        return std::make_optional(std::forward<T>(value));
    }
}

#elif defined HAS_STD_EXPERIMENTAL_OPTIONAL

namespace opt {
    template<class T>
    using optional = std::experimental::optional<T>;
    using bad_optional_access = std::experimental::bad_optional_access;
    using nullopt_t = std::experimental::nullopt_t;
    using in_place_t = std::experimental::in_place_t;

    constexpr auto nullopt = std::experimental::nullopt;
    constexpr auto in_place = std::experimental::in_place;

    template<class T>
    constexpr auto make_optional(T && value)
    {
        return std::experimental::make_optional(std::forward<T>(value));
    }
}

#endif

Answer 1

A modification of @Jerry's answer:

#pragma once

#if __has_include(<optional>)

#   include <optional>
namespace stdx {
  using namespace ::std;
}
#elif __has_include(<experimental/optional>)
#   include <experimental/optional>
namespace stdx {
  using namespace ::std;
  using namespace ::std::experimental;
}

#else
#   error <experimental/optional> and <optional> not found
#endif

this has the advantage that the same namespace can be used for all "experimental" features (stdx).

So stdx::optional and stdx::variant both work.

We have to only using namespace ::std::experimental; after at least one <experimental/ header is included, as if it does not exist that is ill formed, and introducing one ourselves also makes the program ill formed.

Answer 2

Although there are definitely (at times annoying) limitations on what they can do, at first glance it looks like they don't apply here so I'd at least attempt to use a namespace alias:

#pragma once

#if __has_include(<optional>)

#   include <optional>
    using namespace opt = std;

#elif __has_include(<experimental/optional>)
#   include <experimental/optional>

    using namespace opt = std::experimental;

#else
#   error Must have an optional type, either from <optional> or if not supported from <experimental/optional>.
#endif

Then from that point, you just use: opt::whatever, and that maps to either std::whatever or std::experimental::whatever, as appropriate.

Answer 3

Similar to the other answers, but just for optional, without bringing in the rest of std::experimental. Incidentally, we use this in a real codebase:

#pragma once

#if __has_include(<optional>)

#include <optional>
namespace stdx {
    using std::optional;
    using std::nullopt_t;
    using std::in_place_t;
    using std::bad_optional_access;
    using std::nullopt;
    using std::in_place;
    using std::make_optional;
}

#elif __has_include(<experimental/optional>)

#include <experimental/optional>
namespace stdx {
    using std::experimental::optional;
    using std::experimental::nullopt_t;
    using std::experimental::in_place_t;
    using std::experimental::bad_optional_access;
    using std::experimental::nullopt;
    using std::experimental::in_place;
    using std::experimental::make_optional;
}

#else
    #error "an implementation of optional is required!"
#endif