diff --git a/.travis.yml b/.travis.yml
new file mode 100644
index 0000000..1b1f780
--- /dev/null
+++ b/.travis.yml
@@ -0,0 +1,225 @@
+# Copyright 2016 Peter Dimov
+# Distributed under the Boost Software License, Version 1.0.
+# (See accompanying file LICENSE_1_0.txt or copy at http://boost.org/LICENSE_1_0.txt)
+
+language: cpp
+
+sudo: false
+
+python: "2.7"
+
+os:
+  - linux
+  - osx
+
+branches:
+  only:
+    - master
+    - develop
+
+env:
+  matrix:
+    - BOGUS_JOB=true
+
+matrix:
+
+  exclude:
+    - env: BOGUS_JOB=true
+
+  include:
+    - os: linux
+      compiler: g++-5
+      env: TOOLSET=gcc COMPILER=g++-5 CXXSTD=c++14
+      addons:
+        apt:
+          packages:
+            - g++-5
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: g++-5
+      env: TOOLSET=gcc COMPILER=g++-5 CXXSTD=c++1z
+      addons:
+        apt:
+          packages:
+            - g++-5
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: g++-6
+      env: TOOLSET=gcc COMPILER=g++-6 CXXSTD=c++14
+      addons:
+        apt:
+          packages:
+            - g++-6
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: g++-6
+      env: TOOLSET=gcc COMPILER=g++-6 CXXSTD=c++1z
+      addons:
+        apt:
+          packages:
+            - g++-6
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      dist: trusty
+      compiler: g++-7
+      env: TOOLSET=gcc COMPILER=g++-7 CXXSTD=c++14
+      addons:
+        apt:
+          packages:
+            - g++-7
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      dist: trusty
+      compiler: g++-7
+      env: TOOLSET=gcc COMPILER=g++-7 CXXSTD=c++1z
+      addons:
+        apt:
+          packages:
+            - g++-7
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: clang++-3.5
+      env: TOOLSET=clang COMPILER=clang++-3.5 CXXSTD=c++14
+      addons:
+        apt:
+          packages:
+            - clang-3.5
+            - libstdc++-4.9-dev
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-precise-3.5
+
+    - os: linux
+      compiler: clang++-3.6
+      env: TOOLSET=clang COMPILER=clang++-3.6 CXXSTD=c++14
+      addons:
+        apt:
+          packages:
+            - clang-3.6
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-precise-3.6
+
+    - os: linux
+      compiler: clang++-3.7
+      env: TOOLSET=clang COMPILER=clang++-3.7 CXXSTD=c++14
+      addons:
+        apt:
+          packages:
+            - clang-3.7
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-precise-3.7
+
+    - os: linux
+      compiler: clang++-3.8
+      env: TOOLSET=clang COMPILER=clang++-3.8 CXXSTD=c++14
+      addons:
+        apt:
+          packages:
+            - clang-3.8
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-precise-3.8
+
+    - os: linux
+      compiler: clang++-3.8
+      env: TOOLSET=clang COMPILER=clang++-3.8 CXXSTD=c++1z
+      addons:
+        apt:
+          packages:
+            - clang-3.8
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-precise-3.8
+
+    - os: linux
+      compiler: clang++-3.9
+      env: TOOLSET=clang COMPILER=clang++-3.9 CXXSTD=c++14
+      addons:
+        apt:
+          packages:
+            - clang-3.9
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-precise-3.9
+
+    - os: linux
+      compiler: clang++-3.9
+      env: TOOLSET=clang COMPILER=clang++-3.9 CXXSTD=c++1z
+      addons:
+        apt:
+          packages:
+            - clang-3.9
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-precise-3.9
+
+    - os: linux
+      dist: trusty
+      compiler: clang++-4.0
+      env: TOOLSET=clang COMPILER=clang++-4.0 CXXSTD=c++14
+      addons:
+        apt:
+          packages:
+            - clang-4.0
+            - libstdc++-4.9-dev
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-trusty-4.0
+
+    - os: linux
+      dist: trusty
+      compiler: clang++-4.0
+      env: TOOLSET=clang COMPILER=clang++-4.0 CXXSTD=c++1z
+      addons:
+        apt:
+          packages:
+            - clang-4.0
+            - libstdc++-4.9-dev
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-trusty-4.0
+
+    - os: osx
+      compiler: clang++
+      env: TOOLSET=clang COMPILER=clang++ CXXSTD=c++14
+
+    - os: osx
+      compiler: clang++
+      env: TOOLSET=clang COMPILER=clang++ CXXSTD=c++1z
+
+install:
+  - cd ..
+  - git clone -b $TRAVIS_BRANCH --depth 1 https://github.com/boostorg/boost.git boost-root
+  - cd boost-root
+  - git submodule update --init tools/build
+  - git submodule update --init libs/config
+  - git submodule update --init tools/boostdep
+  - git clone -b $TRAVIS_BRANCH https://github.com/pdimov/mp11 libs/mp11
+  - mkdir libs/variant2
+  - cp -r $TRAVIS_BUILD_DIR/* libs/variant2
+  - python tools/boostdep/depinst/depinst.py variant2
+  - ./bootstrap.sh
+  - ./b2 headers
+
+script:
+  - |-
+    echo "using $TOOLSET : : $COMPILER : <cxxflags>-std=$CXXSTD ;" > ~/user-config.jam
+  - ./b2 libs/variant2/test toolset=$TOOLSET
+
+notifications:
+  email:
+    on_success: always
diff --git a/README.md b/README.md
index 372c949..972145e 100644
--- a/README.md
+++ b/README.md
@@ -1,2 +1,14 @@
 # variant2
-A never-valueless implementation of std::variant
+
+A never-valueless C++14 implementation of [std::variant](http://en.cppreference.com/w/cpp/utility/variant). Requires [mp11](https://github.com/pdimov/mp11) and Boost.Config. Intended to be placed into the `libs/variant2` directory of a Boost clone or release, with mp11 in `libs/mp11`.
+
+To avoid the valueless state, this implementation falls back to using double storage unless
+
+* all the contained types are nothrow move constructible, or
+* at least one contained type has a nothrow default constructor.
+
+Supported compilers:
+
+* g++ 5 or later with -std=c++14 or -std=c++1z
+* clang++ 3.5 or later with -std=c++14 or -std=c++1z
+* Visual Studio 2017
diff --git a/appveyor.yml b/appveyor.yml
new file mode 100644
index 0000000..152eb22
--- /dev/null
+++ b/appveyor.yml
@@ -0,0 +1,36 @@
+# Copyright 2016 Peter Dimov
+# Distributed under the Boost Software License, Version 1.0.
+# (See accompanying file LICENSE_1_0.txt or copy at http://boost.org/LICENSE_1_0.txt)
+
+version: 1.0.{build}-{branch}
+
+shallow_clone: true
+
+branches:
+  only:
+    - master
+    - develop
+
+environment:
+  matrix:
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
+      TOOLSET: msvc-14.1
+
+install:
+  - cd ..
+  - git clone -b %APPVEYOR_REPO_BRANCH% --depth 1 https://github.com/boostorg/boost.git boost-root
+  - cd boost-root
+  - git submodule update --init tools/build
+  - git submodule update --init libs/config
+  - git submodule update --init tools/boostdep
+  - git clone -b %APPVEYOR_REPO_BRANCH% https://github.com/pdimov/mp11 libs/mp11
+  - mkdir libs\variant2
+  - xcopy /s /e /q %APPVEYOR_BUILD_FOLDER% libs\variant2
+  - python tools/boostdep/depinst/depinst.py variant2
+  - bootstrap
+  - b2 headers
+
+build: off
+
+test_script:
+  - b2 libs/variant2/test toolset=%TOOLSET%
diff --git a/include/boost/variant2/variant.hpp b/include/boost/variant2/variant.hpp
new file mode 100644
index 0000000..4ce586e
--- /dev/null
+++ b/include/boost/variant2/variant.hpp
@@ -0,0 +1,1154 @@
+#ifndef BOOST_VARIANT2_VARIANT_HPP_INCLUDED
+#define BOOST_VARIANT2_VARIANT_HPP_INCLUDED
+
+//  Copyright 2015-2017 Peter Dimov.
+//
+//  Distributed under the Boost Software License, Version 1.0.
+//
+//  See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/mp11.hpp>
+#include <boost/config.hpp>
+#include <boost/detail/workaround.hpp>
+#include <cstddef>
+#include <type_traits>
+#include <exception>
+#include <cassert>
+#include <initializer_list>
+#include <utility>
+
+//
+
+namespace boost
+{
+namespace variant2
+{
+
+using namespace boost::mp11;
+
+// bad_variant_access
+
+class bad_variant_access: public std::exception
+{
+public:
+
+    bad_variant_access() noexcept
+    {
+    }
+
+    char const * what() const noexcept
+    {
+        return "bad_variant_access";
+    }
+};
+
+//
+
+template<class... T> class variant;
+
+// variant_size
+
+template<class T> struct variant_size
+{
+};
+
+template<class T> struct variant_size<T const>: variant_size<T>
+{
+};
+
+template<class T> struct variant_size<T volatile>: variant_size<T>
+{
+};
+
+template<class T> struct variant_size<T const volatile>: variant_size<T>
+{
+};
+
+template <class T> /*inline*/ constexpr std::size_t variant_size_v = variant_size<T>::value;
+
+template <class... T> struct variant_size<variant<T...>>: mp_size<variant<T...>>
+{
+};
+
+// variant_alternative
+
+template<std::size_t I, class T> struct variant_alternative;
+
+template<std::size_t I, class T> using variant_alternative_t = typename variant_alternative<I, T>::type;
+
+namespace detail
+{
+    template<class I, class T, class Q> using var_alt_t = mp_invoke<Q, variant_alternative_t<I::value, T>>;
+} // namespace detail
+
+template<std::size_t I, class T> struct variant_alternative
+{
+};
+
+template<std::size_t I, class T> struct variant_alternative<I, T const>: mp_defer< variant2::detail::var_alt_t, mp_size_t<I>, T, mp_quote<std::add_const_t>>
+{
+};
+
+template<std::size_t I, class T> struct variant_alternative<I, T volatile>: mp_defer< variant2::detail::var_alt_t, mp_size_t<I>, T, mp_quote<std::add_volatile_t>>
+{
+};
+
+template<std::size_t I, class T> struct variant_alternative<I, T const volatile>: mp_defer< variant2::detail::var_alt_t, mp_size_t<I>, T, mp_quote<std::add_cv_t>>
+{
+};
+
+template<std::size_t I, class... T> struct variant_alternative<I, variant<T...>>: mp_defer<mp_at, variant<T...>, mp_size_t<I>>
+{
+};
+
+// holds_alternative
+
+template<class U, class... T> constexpr bool holds_alternative( variant<T...> const& v ) noexcept
+{
+    static_assert( mp_count<variant<T...>, U>::value == 1, "The type must occur exactly once in the list of variant alternatives" );
+    return v.index() == mp_find<variant<T...>, U>::value;
+}
+
+// get
+
+template<std::size_t I, class... T> constexpr variant_alternative_t<I, variant<T...>>& get(variant<T...>& v)
+{
+    static_assert( I < sizeof...(T), "Index out of bounds" );
+
+#if BOOST_WORKAROUND( BOOST_GCC, < 60000 )
+
+    return (void)( v.index() != I? throw bad_variant_access(): 0 ), v._get_impl( mp_size_t<I>() );
+
+#else
+
+    if( v.index() != I ) throw bad_variant_access();
+    return v._get_impl( mp_size_t<I>() );
+
+#endif
+}
+
+template<std::size_t I, class... T> constexpr variant_alternative_t<I, variant<T...>>&& get(variant<T...>&& v)
+{
+    static_assert( I < sizeof...(T), "Index out of bounds" );
+
+#if BOOST_WORKAROUND( BOOST_GCC, < 60000 )
+
+    return (void)( v.index() != I? throw bad_variant_access(): 0 ), std::move( v._get_impl( mp_size_t<I>() ) );
+
+#else
+
+    if( v.index() != I ) throw bad_variant_access();
+    return std::move( v._get_impl( mp_size_t<I>() ) );
+
+#endif
+}
+
+template<std::size_t I, class... T> constexpr variant_alternative_t<I, variant<T...>> const& get(variant<T...> const& v)
+{
+    static_assert( I < sizeof...(T), "Index out of bounds" );
+
+#if BOOST_WORKAROUND( BOOST_GCC, < 60000 )
+
+    return (void)( v.index() != I? throw bad_variant_access(): 0 ), v._get_impl( mp_size_t<I>() );
+
+#else
+
+    if( v.index() != I ) throw bad_variant_access();
+    return v._get_impl( mp_size_t<I>() );
+
+#endif
+}
+
+template<std::size_t I, class... T> constexpr variant_alternative_t<I, variant<T...>> const&& get(variant<T...> const&& v)
+{
+    static_assert( I < sizeof...(T), "Index out of bounds" );
+
+#if BOOST_WORKAROUND( BOOST_GCC, < 60000 )
+
+    return (void)( v.index() != I? throw bad_variant_access(): 0 ), std::move( v._get_impl( mp_size_t<I>() ) );
+
+#else
+
+    if( v.index() != I ) throw bad_variant_access();
+    return std::move( v._get_impl( mp_size_t<I>() ) );
+
+#endif
+}
+
+// get
+
+template<class U, class... T> constexpr U& get(variant<T...>& v)
+{
+    static_assert( mp_count<variant<T...>, U>::value == 1, "The type must occur exactly once in the list of variant alternatives" );
+    constexpr auto I = mp_find<variant<T...>, U>::value;
+
+#if BOOST_WORKAROUND( BOOST_GCC, < 60000 )
+
+    return (void)( v.index() != I? throw bad_variant_access(): 0 ), v._get_impl( mp_size_t<I>() );
+
+#else
+
+    if( v.index() != I ) throw bad_variant_access();
+    return v._get_impl( mp_size_t<I>() );
+
+#endif
+}
+
+template<class U, class... T> constexpr U&& get(variant<T...>&& v)
+{
+    static_assert( mp_count<variant<T...>, U>::value == 1, "The type must occur exactly once in the list of variant alternatives" );
+    constexpr auto I = mp_find<variant<T...>, U>::value;
+
+#if BOOST_WORKAROUND( BOOST_GCC, < 60000 )
+
+    return (void)( v.index() != I? throw bad_variant_access(): 0 ), std::move( v._get_impl( mp_size_t<I>() ) );
+
+#else
+
+    if( v.index() != I ) throw bad_variant_access();
+    return std::move( v._get_impl( mp_size_t<I>() ) );
+
+#endif
+}
+
+template<class U, class... T> constexpr U const& get(variant<T...> const& v)
+{
+    static_assert( mp_count<variant<T...>, U>::value == 1, "The type must occur exactly once in the list of variant alternatives" );
+    constexpr auto I = mp_find<variant<T...>, U>::value;
+
+#if BOOST_WORKAROUND( BOOST_GCC, < 60000 )
+
+    return (void)( v.index() != I? throw bad_variant_access(): 0 ), v._get_impl( mp_size_t<I>() );
+
+#else
+
+    if( v.index() != I ) throw bad_variant_access();
+    return v._get_impl( mp_size_t<I>() );
+
+#endif
+}
+
+template<class U, class... T> constexpr U const&& get(variant<T...> const&& v)
+{
+    static_assert( mp_count<variant<T...>, U>::value == 1, "The type must occur exactly once in the list of variant alternatives" );
+    constexpr auto I = mp_find<variant<T...>, U>::value;
+
+#if BOOST_WORKAROUND( BOOST_GCC, < 60000 )
+
+    return (void)( v.index() != I? throw bad_variant_access(): 0 ), std::move( v._get_impl( mp_size_t<I>() ) );
+
+#else
+
+    if( v.index() != I ) throw bad_variant_access();
+    return std::move( v._get_impl( mp_size_t<I>() ) );
+
+#endif
+}
+
+// get_if
+
+template<std::size_t I, class... T> constexpr std::add_pointer_t<variant_alternative_t<I, variant<T...>>> get_if(variant<T...>* v) noexcept
+{
+    static_assert( I < sizeof...(T), "Index out of bounds" );
+    return v->index() == I? &v->_get_impl( mp_size_t<I>() ): 0;
+}
+
+template<std::size_t I, class... T> constexpr std::add_pointer_t<const variant_alternative_t<I, variant<T...>>> get_if(variant<T...> const * v) noexcept
+{
+    static_assert( I < sizeof...(T), "Index out of bounds" );
+    return v->index() == I? &v->_get_impl( mp_size_t<I>() ): 0;
+}
+
+template<class U, class... T> constexpr std::add_pointer_t<U> get_if(variant<T...>* v) noexcept
+{
+    static_assert( mp_count<variant<T...>, U>::value == 1, "The type must occur exactly once in the list of variant alternatives" );
+    constexpr auto I = mp_find<variant<T...>, U>::value;
+
+    return v->index() == I? &v->_get_impl( mp_size_t<I>() ): 0;
+}
+
+template<class U, class... T> constexpr std::add_pointer_t<U const> get_if(variant<T...> const * v) noexcept
+{
+    static_assert( mp_count<variant<T...>, U>::value == 1, "The type must occur exactly once in the list of variant alternatives" );
+    constexpr auto I = mp_find<variant<T...>, U>::value;
+
+    return v->index() == I? &v->_get_impl( mp_size_t<I>() ): 0;
+}
+
+//
+
+namespace detail
+{
+
+// variant_storage
+
+template<class D, class... T> union variant_storage_impl;
+
+template<class... T> using variant_storage = variant_storage_impl<mp_all<std::is_trivially_destructible<T>...>, T...>;
+
+template<class D> union variant_storage_impl<D>
+{
+};
+
+// not all trivially destructible
+template<class T1, class... T> union variant_storage_impl<mp_false, T1, T...>
+{
+    T1 first_;
+    variant_storage<T...> rest_;
+
+    template<class... A> constexpr explicit variant_storage_impl( mp_size_t<0>, A&&... a ): first_( std::forward<A>(a)... )
+    {
+    }
+
+    template<std::size_t I, class... A> constexpr explicit variant_storage_impl( mp_size_t<I>, A&&... a ): rest_( mp_size_t<I-1>(), std::forward<A>(a)... )
+    {
+    }
+
+    ~variant_storage_impl()
+    {
+    }
+
+    template<class... A> void emplace( mp_size_t<0>, A&&... a ) noexcept
+    {
+        ::new( &first_ ) T1( std::forward<A>(a)... );
+    }
+
+    template<std::size_t I, class... A> void emplace( mp_size_t<I>, A&&... a ) noexcept
+    {
+        rest_.emplace( mp_size_t<I-1>(), std::forward<A>(a)... );
+    }
+
+    constexpr T1& get( mp_size_t<0> ) noexcept { return first_; }
+    constexpr T1 const& get( mp_size_t<0> ) const noexcept { return first_; }
+
+    template<std::size_t I> constexpr mp_at_c<mp_list<T...>, I-1>& get( mp_size_t<I> ) noexcept { return rest_.get( mp_size_t<I-1>() ); }
+    template<std::size_t I> constexpr mp_at_c<mp_list<T...>, I-1> const& get( mp_size_t<I> ) const noexcept { return rest_.get( mp_size_t<I-1>() ); }
+};
+
+// all trivially destructible
+template<class T1, class... T> union variant_storage_impl<mp_true, T1, T...>
+{
+    T1 first_;
+    variant_storage<T...> rest_;
+
+    template<class... A> constexpr explicit variant_storage_impl( mp_size_t<0>, A&&... a ): first_( std::forward<A>(a)... )
+    {
+    }
+
+    template<std::size_t I, class... A> constexpr explicit variant_storage_impl( mp_size_t<I>, A&&... a ): rest_( mp_size_t<I-1>(), std::forward<A>(a)... )
+    {
+    }
+
+    template<class... A> void emplace( mp_size_t<0>, A&&... a ) noexcept
+    {
+        ::new( &first_ ) T1( std::forward<A>(a)... );
+    }
+
+    template<std::size_t I, class... A> void emplace( mp_size_t<I>, A&&... a ) noexcept
+    {
+        rest_.emplace( mp_size_t<I-1>(), std::forward<A>(a)... );
+    }
+
+    constexpr T1& get( mp_size_t<0> ) noexcept { return first_; }
+    constexpr T1 const& get( mp_size_t<0> ) const noexcept { return first_; }
+
+    template<std::size_t I> constexpr mp_at_c<mp_list<T...>, I-1>& get( mp_size_t<I> ) noexcept { return rest_.get( mp_size_t<I-1>() ); }
+    template<std::size_t I> constexpr mp_at_c<mp_list<T...>, I-1> const& get( mp_size_t<I> ) const noexcept { return rest_.get( mp_size_t<I-1>() ); }
+};
+
+// resolve_overload_*
+
+template<class... T> struct overload;
+
+template<> struct overload<>
+{
+    void operator()() const;
+};
+
+template<class T1, class... T> struct overload<T1, T...>: overload<T...>
+{
+    using overload<T...>::operator();
+    mp_identity<T1> operator()(T1) const;
+};
+
+#if BOOST_WORKAROUND( BOOST_MSVC, <= 1910 )
+
+template<class U, class... T> struct resolve_overload_type_impl
+{
+    using type = decltype( overload<T...>()(std::declval<U>()) );
+};
+
+template<class U, class... T> using resolve_overload_type = typename resolve_overload_type_impl<U, T...>::type::type;
+
+#else
+
+template<class U, class... T> using resolve_overload_type = typename decltype( overload<T...>()(std::declval<U>()) )::type;
+
+#endif
+
+template<class U, class... T> using resolve_overload_index = mp_find<mp_list<T...>, resolve_overload_type<U, T...>>;
+
+// variant_base
+
+template<bool is_trivially_destructible, bool is_single_buffered, class... T> struct variant_base_impl; // trivially destructible, single buffered
+template<class... T> using variant_base = variant_base_impl<mp_all<std::is_trivially_destructible<T>...>::value, mp_any<mp_all<std::is_nothrow_move_constructible<T>...>, std::is_nothrow_default_constructible<T>...>::value, T...>;
+
+struct none {};
+
+// trivially destructible, single buffered
+template<class... T> struct variant_base_impl<true, true, T...>
+{
+    int ix_;
+    variant_storage<none, T...> st1_;
+
+    constexpr variant_base_impl(): ix_( 0 ), st1_( mp_size_t<0>() )
+    {
+    }
+
+    template<class I, class... A> constexpr explicit variant_base_impl( I, A&&... a ): ix_( I::value + 1 ), st1_( mp_size_t<I::value + 1>(), std::forward<A>(a)... )
+    {
+    }
+
+    template<std::size_t I> constexpr mp_at_c<variant<T...>, I>& _get_impl( mp_size_t<I> ) noexcept
+    {
+        size_t const J = I+1;
+
+        assert( ix_ == J );
+
+        return st1_.get( mp_size_t<J>() );
+    }
+
+    template<std::size_t I> constexpr mp_at_c<variant<T...>, I> const& _get_impl( mp_size_t<I> ) const noexcept
+    {
+        size_t const J = I+1;
+
+        assert( ix_ == J );
+
+        return st1_.get( mp_size_t<J>() );
+    }
+
+    template<std::size_t I, class... A> void emplace( A&&... a )
+    {
+        std::size_t const J = I+1;
+
+        std::size_t const K = mp_find_if<mp_list<T...>, std::is_nothrow_constructible>::value;
+
+        using U = mp_at_c<variant<T...>, I>;
+
+        if( std::is_nothrow_constructible<U, A...>::value )
+        {
+            st1_.emplace( mp_size_t<J>(), std::forward<A>(a)... );
+            ix_ = J;
+        }
+        else if( K < sizeof...(T) ) // have nothrow destructible
+        {
+            try
+            {
+                st1_.emplace( mp_size_t<J>(), std::forward<A>(a)... );
+                ix_ = J;
+            }
+            catch( ... )
+            {
+                st1_.emplace( mp_size_t<K>() );
+                ix_ = K;
+
+                throw;
+            }
+        }
+        else
+        {
+            assert( std::is_nothrow_move_constructible<U>::value );
+
+            U tmp( std::forward<A>(a)... );
+
+            st1_.emplace( mp_size_t<J>(), std::move(tmp) );
+            ix_ = J;
+        }
+    }
+};
+
+// trivially destructible, double buffered
+template<class... T> struct variant_base_impl<true, false, T...>
+{
+    int ix_;
+    variant_storage<none, T...> st1_;
+    variant_storage<none, T...> st2_;
+
+    constexpr variant_base_impl(): ix_( 0 ), st1_( mp_size_t<0>() ), st2_( mp_size_t<0>() )
+    {
+    }
+
+    template<class I, class... A> constexpr explicit variant_base_impl( I, A&&... a ): ix_( I::value + 1 ), st1_( mp_size_t<I::value + 1>(), std::forward<A>(a)... ), st2_( mp_size_t<0>() )
+    {
+    }
+
+    template<std::size_t I> constexpr mp_at_c<variant<T...>, I>& _get_impl( mp_size_t<I> ) noexcept
+    {
+        size_t const J = I+1;
+
+        assert( ix_ == J || -ix_ == J );
+
+        constexpr mp_size_t<J> j{};
+        return ix_ >= 0? st1_.get( j ): st2_.get( j );
+    }
+
+    template<std::size_t I> constexpr mp_at_c<variant<T...>, I> const& _get_impl( mp_size_t<I> ) const noexcept
+    {
+        size_t const J = I+1;
+
+        assert( ix_ == J || -ix_ == J );
+
+        constexpr mp_size_t<J> j{};
+        return ix_ >= 0? st1_.get( j ): st2_.get( j );
+    }
+
+    template<std::size_t I, class... A> void emplace( A&&... a )
+    {
+        size_t const J = I+1;
+
+        if( ix_ >= 0 )
+        {
+            st2_.emplace( mp_size_t<J>(), std::forward<A>(a)... );
+            ix_ = -static_cast<int>( J );
+        }
+        else
+        {
+            st1_.emplace( mp_size_t<J>(), std::forward<A>(a)... );
+            ix_ = J;
+        }
+    }
+};
+
+// not trivially destructible, single buffered
+template<class... T> struct variant_base_impl<false, true, T...>
+{
+    int ix_;
+    variant_storage<none, T...> st1_;
+
+    constexpr variant_base_impl(): ix_( 0 ), st1_( mp_size_t<0>() )
+    {
+    }
+
+    template<class I, class... A> constexpr explicit variant_base_impl( I, A&&... a ): ix_( I::value + 1 ), st1_( mp_size_t<I::value + 1>(), std::forward<A>(a)... )
+    {
+    }
+
+    void _destroy() noexcept
+    {
+        if( ix_ > 0 )
+        {
+            mp_for_index<1 + sizeof...(T)>( ix_, [&]( auto I ){
+
+                using U = mp_at_c<mp_list<none, T...>, I>;
+                st1_.get( I ).~U();
+
+            });
+        }
+    }
+
+    ~variant_base_impl() noexcept
+    {
+        _destroy();
+    }
+
+    template<std::size_t I> constexpr mp_at_c<variant<T...>, I>& _get_impl( mp_size_t<I> ) noexcept
+    {
+        size_t const J = I+1;
+
+        assert( ix_ == J );
+
+        return st1_.get( mp_size_t<J>() );
+    }
+
+    template<std::size_t I> constexpr mp_at_c<variant<T...>, I> const& _get_impl( mp_size_t<I> ) const noexcept
+    {
+        size_t const J = I+1;
+
+        assert( ix_ == J );
+
+        return st1_.get( mp_size_t<J>() );
+    }
+
+    template<std::size_t I, class... A> void emplace( A&&... a )
+    {
+        size_t const J = I+1;
+
+        std::size_t const K = mp_find_if<mp_list<T...>, std::is_nothrow_constructible>::value;
+
+        using U = mp_at_c<variant<T...>, I>;
+
+        if( std::is_nothrow_constructible<U, A...>::value )
+        {
+            _destroy();
+
+            st1_.emplace( mp_size_t<J>(), std::forward<A>(a)... );
+            ix_ = J;
+        }
+        else if( K < sizeof...(T) ) // have nothrow destructible
+        {
+            _destroy();
+
+            try
+            {
+                st1_.emplace( mp_size_t<J>(), std::forward<A>(a)... );
+                ix_ = J;
+            }
+            catch( ... )
+            {
+                st1_.emplace( mp_size_t<K>() );
+                ix_ = K;
+
+                throw;
+            }
+        }
+        else
+        {
+            assert( std::is_nothrow_move_constructible<U>::value );
+
+            U tmp( std::forward<A>(a)... );
+
+            _destroy();
+
+            st1_.emplace( mp_size_t<J>(), std::move(tmp) );
+            ix_ = J;
+        }
+    }
+};
+
+// not trivially destructible, double buffered
+template<class... T> struct variant_base_impl<false, false, T...>
+{
+    int ix_;
+    variant_storage<none, T...> st1_;
+    variant_storage<none, T...> st2_;
+
+    constexpr variant_base_impl(): ix_( 0 ), st1_( mp_size_t<0>() ), st2_( mp_size_t<0>() )
+    {
+    }
+
+    template<class I, class... A> constexpr explicit variant_base_impl( I, A&&... a ): ix_( I::value + 1 ), st1_( mp_size_t<I::value + 1>(), std::forward<A>(a)... ), st2_( mp_size_t<0>() )
+    {
+    }
+
+    void _destroy() noexcept
+    {
+        if( ix_ > 0 )
+        {
+            mp_for_index<1 + sizeof...(T)>( ix_, [&]( auto I ){
+
+                using U = mp_at_c<mp_list<none, T...>, I>;
+                st1_.get( I ).~U();
+
+            });
+        }
+        else if( ix_ < 0 )
+        {
+            mp_for_index<1 + sizeof...(T)>( -ix_, [&]( auto I ){
+
+                using U = mp_at_c<mp_list<none, T...>, I>;
+                st2_.get( I ).~U();
+
+            });
+        }
+    }
+
+    ~variant_base_impl() noexcept
+    {
+        _destroy();
+    }
+
+    template<std::size_t I> constexpr mp_at_c<variant<T...>, I>& _get_impl( mp_size_t<I> ) noexcept
+    {
+        size_t const J = I+1;
+
+        assert( ix_ == J || -ix_ == J );
+
+        constexpr mp_size_t<J> j{};
+        return ix_ >= 0? st1_.get( j ): st2_.get( j );
+    }
+
+    template<std::size_t I> constexpr mp_at_c<variant<T...>, I> const& _get_impl( mp_size_t<I> ) const noexcept
+    {
+        size_t const J = I+1;
+
+        assert( ix_ == J || -ix_ == J );
+
+        constexpr mp_size_t<J> j{};
+        return ix_ >= 0? st1_.get( j ): st2_.get( j );
+    }
+
+    template<std::size_t I, class... A> void emplace( A&&... a )
+    {
+        size_t const J = I+1;
+
+        if( ix_ >= 0 )
+        {
+            st2_.emplace( mp_size_t<J>(), std::forward<A>(a)... );
+            _destroy();
+
+            ix_ = -static_cast<int>( J );
+        }
+        else
+        {
+            st1_.emplace( mp_size_t<J>(), std::forward<A>(a)... );
+            _destroy();
+
+            ix_ = J;
+        }
+    }
+};
+
+} // namespace detail
+
+// in_place_type_t
+
+template<class T> struct in_place_type_t
+{
+};
+
+template<class T> constexpr in_place_type_t<T> in_place_type{};
+
+namespace detail
+{
+
+template<class T> struct is_in_place_type: std::false_type {};
+template<class T> struct is_in_place_type<in_place_type_t<T>>: std::true_type {};
+
+} // namespace detail
+
+// in_place_index_t
+
+template<std::size_t I> struct in_place_index_t
+{
+};
+
+template<std::size_t I> constexpr in_place_index_t<I> in_place_index{};
+
+namespace detail
+{
+
+template<class T> struct is_in_place_index: std::false_type {};
+template<std::size_t I> struct is_in_place_index<in_place_index_t<I>>: std::true_type {};
+
+} // namespace detail
+
+// is_nothrow_swappable
+
+namespace detail
+{
+
+namespace det2
+{
+
+using std::swap;
+
+template<class T> using is_swappable_impl = decltype(swap(std::declval<T&>(), std::declval<T&>()));
+
+#if BOOST_WORKAROUND( BOOST_MSVC, <= 1910 )
+
+template<class T> struct is_nothrow_swappable_impl_
+{
+    static constexpr bool value = noexcept(swap(std::declval<T&>(), std::declval<T&>()));
+};
+
+template<class T> using is_nothrow_swappable_impl = mp_bool< is_nothrow_swappable_impl_<T>::value >;
+
+#else
+
+template<class T> using is_nothrow_swappable_impl = std::enable_if_t<noexcept(swap(std::declval<T&>(), std::declval<T&>()))>;
+
+#endif
+
+} // namespace det2
+
+template<class T> struct is_swappable: mp_valid<det2::is_swappable_impl, T>
+{
+};
+
+#if BOOST_WORKAROUND( BOOST_MSVC, <= 1910 )
+
+template<class T> struct is_nothrow_swappable: mp_eval_if<mp_not<is_swappable<T>>, mp_false, det2::is_nothrow_swappable_impl, T>
+{
+};
+
+#else
+
+template<class T> struct is_nothrow_swappable: mp_valid<det2::is_nothrow_swappable_impl, T>
+{
+};
+
+#endif
+
+} // namespace detail
+
+// variant
+
+template<class... T> class variant: private variant2::detail::variant_base<T...>
+{
+private:
+
+    using variant_base = variant2::detail::variant_base<T...>;
+
+private:
+
+    variant( variant const volatile& r ) = delete;
+    variant& operator=( variant const volatile& r ) = delete;
+
+public:
+
+    // constructors
+
+    template<class E1 = void, class E2 = mp_if<std::is_default_constructible< mp_first<variant<T...>> >, E1>>
+    constexpr variant()
+        noexcept( std::is_nothrow_default_constructible< mp_first<variant<T...>> >::value )
+        : variant_base( mp_size_t<0>() )
+    {
+    }
+
+    template<class E1 = void, class E2 = mp_if<mp_all<std::is_copy_constructible<T>...>, E1>>
+    variant( variant const& r )
+        noexcept( mp_all<std::is_nothrow_copy_constructible<T>...>::value )
+    {
+        mp_for_index<sizeof...(T)>( r.index(), [&]( auto I ){
+
+            ::new( static_cast<variant_base*>(this) ) variant_base( I, r._get_impl( I ) );
+
+        });
+    }
+
+    template<class E1 = void, class E2 = mp_if<mp_all<std::is_move_constructible<T>...>, E1>>
+    variant( variant && r )
+        noexcept( mp_all<std::is_nothrow_move_constructible<T>...>::value )
+    {
+        mp_for_index<sizeof...(T)>( r.index(), [&]( auto I ){
+
+            ::new( static_cast<variant_base*>(this) ) variant_base( I, std::move( r._get_impl( I ) ) );
+
+        });
+    }
+
+    template<class U,
+        class Ud = std::decay_t<U>,
+        class E1 = std::enable_if_t< !std::is_same<Ud, variant>::value && !variant2::detail::is_in_place_index<Ud>::value && !variant2::detail::is_in_place_type<Ud>::value >,
+        class V = variant2::detail::resolve_overload_type<U&&, T...>,
+        class E2 = std::enable_if_t<std::is_constructible<V, U>::value>
+        >
+    constexpr variant( U&& u )
+        noexcept( std::is_nothrow_constructible<V, U>::value )
+        : variant_base( variant2::detail::resolve_overload_index<U&&, T...>(), std::forward<U>(u) )
+    {
+    }
+
+    template<class U, class... A, class I = mp_find<variant<T...>, U>, class E = std::enable_if_t<std::is_constructible<U, A...>::value>>
+    constexpr explicit variant( in_place_type_t<U>, A&&... a ): variant_base( I(), std::forward<A>(a)... )
+    {
+    }
+
+    template<class U, class V, class... A, class I = mp_find<variant<T...>, U>, class E = std::enable_if_t<std::is_constructible<U, std::initializer_list<V>&, A...>::value>>
+    constexpr explicit variant( in_place_type_t<U>, std::initializer_list<V> il, A&&... a ): variant_base( I(), il, std::forward<A>(a)... )
+    {
+    }
+
+    template<std::size_t I, class... A, class E = std::enable_if_t<std::is_constructible<mp_at_c<variant<T...>, I>, A...>::value>>
+    constexpr explicit variant( in_place_index_t<I>, A&&... a ): variant_base( mp_size_t<I>(), std::forward<A>(a)... )
+    {
+    }
+
+    template<std::size_t I, class V, class... A, class E = std::enable_if_t<std::is_constructible<mp_at_c<variant<T...>, I>, std::initializer_list<V>&, A...>::value>>
+    constexpr explicit variant( in_place_index_t<I>, std::initializer_list<V> il, A&&... a ): variant_base( mp_size_t<I>(), il, std::forward<A>(a)... )
+    {
+    }
+
+    // assignment
+    template<class E1 = void, class E2 = mp_if<mp_all<std::is_copy_constructible<T>..., std::is_copy_assignable<T>...>, E1>>
+    variant& operator=( variant const & r )
+        noexcept( mp_all<std::is_nothrow_copy_constructible<T>..., std::is_nothrow_copy_assignable<T>...>::value )
+    {
+        mp_for_index<sizeof...(T)>( r.index(), [&]( auto I ){
+
+            if( this->index() == I )
+            {
+                get<I>(*this) = get<I>(r);
+            }
+            else
+            {
+                this->variant_base::template emplace<I>( get<I>(r) );
+            }
+
+        });
+
+        return *this;
+    }
+
+    template<class E1 = void, class E2 = mp_if<mp_all<std::is_move_constructible<T>..., std::is_move_assignable<T>...>, E1>>
+    variant& operator=( variant && r )
+        noexcept( mp_all<std::is_nothrow_move_constructible<T>..., std::is_nothrow_move_assignable<T>...>::value )
+    {
+        mp_for_index<sizeof...(T)>( r.index(), [&]( auto I ){
+
+            if( this->index() == I )
+            {
+                get<I>(*this) = get<I>(std::move(r));
+            }
+            else
+            {
+                this->variant_base::template emplace<I>( get<I>(std::move(r)) );
+            }
+
+        });
+
+        return *this;
+    }
+
+    template<class U,
+        class E1 = std::enable_if_t<!std::is_same<std::decay_t<U>, variant>::value>,
+        class V = variant2::detail::resolve_overload_type<U, T...>,
+        class E2 = std::enable_if_t<std::is_assignable<V&, U>::value && std::is_constructible<V, U>::value>
+    >
+    variant& operator=( U&& u )
+        noexcept( std::is_nothrow_assignable<V&, U>::value && std::is_nothrow_constructible<V, U>::value )
+    {
+        std::size_t const I = variant2::detail::resolve_overload_index<U, T...>::value;
+
+        if( index() == I )
+        {
+            _get_impl( mp_size_t<I>() ) = std::forward<U>(u);
+        }
+        else
+        {
+            this->template emplace<I>( std::forward<U>(u) );
+        }
+
+        return *this;
+    }
+
+    // modifiers
+
+    template<class U, class... A, class I = mp_find<variant<T...>, U>, class E = std::enable_if_t<std::is_constructible<U, A...>::value>>
+    U& emplace( A&&... a )
+    {
+        variant_base::template emplace<I::value>( std::forward<A>(a)... );
+        return _get_impl( I() );
+    }
+
+    template<class U, class V, class... A, class I = mp_find<variant<T...>, U>, class E = std::enable_if_t<std::is_constructible<U, std::initializer_list<V>&, A...>::value>>
+    U& emplace( std::initializer_list<V> il, A&&... a )
+    {
+        variant_base::template emplace<I::value>( il, std::forward<A>(a)... );
+        return _get_impl( I() );
+    }
+
+    template<std::size_t I, class... A, class E = std::enable_if_t<std::is_constructible<mp_at_c<variant<T...>, I>, A...>::value>>
+    variant_alternative_t<I, variant<T...>>& emplace( A&&... a )
+    {
+        variant_base::template emplace<I>( std::forward<A>(a)... );
+        return _get_impl( mp_size_t<I>() );
+    }
+
+    template<std::size_t I, class V, class... A, class E = std::enable_if_t<std::is_constructible<mp_at_c<variant<T...>, I>, std::initializer_list<V>&, A...>::value>>
+    variant_alternative_t<I, variant<T...>>& emplace( std::initializer_list<V> il, A&&... a )
+    {
+        variant_base::template emplace<I>( il, std::forward<A>(a)... );
+        return _get_impl( mp_size_t<I>() );
+    }
+
+    // value status
+
+    constexpr size_t index() const noexcept
+    {
+        return this->ix_ >= 0? this->ix_ - 1 : -this->ix_ - 1;
+    }
+
+    // swap
+
+    void swap( variant& r ) noexcept( mp_all<std::is_nothrow_move_constructible<T>..., variant2::detail::is_nothrow_swappable<T>...>::value )
+    {
+        if( index() == r.index() )
+        {
+            mp_for_index<sizeof...(T)>( index(), [&]( auto I ){
+
+                using std::swap;
+                swap( get<I>(*this), get<I>(r) );
+
+            });
+        }
+        else
+        {
+            variant tmp( std::move(*this) );
+            *this = std::move( r );
+            r = std::move( tmp );
+        }
+    }
+
+    // private accessors
+
+    constexpr int _real_index() const noexcept
+    {
+        return this->ix_;
+    }
+
+    using variant_base::_get_impl;
+};
+
+// relational operators
+template<class... T> constexpr bool operator==( variant<T...> const & v, variant<T...> const & w )
+{
+    if( v.index() != w.index() ) return false;
+
+    return mp_for_index<sizeof...(T)>( v.index(), [&]( auto I ){
+
+        return get<I>(v) == get<I>(w);
+
+    });
+}
+
+template<class... T> constexpr bool operator!=( variant<T...> const & v, variant<T...> const & w )
+{
+    if( v.index() != w.index() ) return true;
+
+    return mp_for_index<sizeof...(T)>( v.index(), [&]( auto I ){
+
+        return get<I>(v) != get<I>(w);
+
+    });
+}
+
+template<class... T> constexpr bool operator<( variant<T...> const & v, variant<T...> const & w )
+{
+    if( v.index() < w.index() ) return true;
+    if( v.index() > w.index() ) return false;
+
+    return mp_for_index<sizeof...(T)>( v.index(), [&]( auto I ){
+
+        return get<I>(v) < get<I>(w);
+
+    });
+}
+
+template<class... T> constexpr bool operator>(  variant<T...> const & v, variant<T...> const & w )
+{
+    if( v.index() > w.index() ) return true;
+    if( v.index() < w.index() ) return false;
+
+    return mp_for_index<sizeof...(T)>( v.index(), [&]( auto I ){
+
+        return get<I>(v) > get<I>(w);
+
+    });
+}
+
+template<class... T> constexpr bool operator<=( variant<T...> const & v, variant<T...> const & w )
+{
+    if( v.index() < w.index() ) return true;
+    if( v.index() > w.index() ) return false;
+
+    return mp_for_index<sizeof...(T)>( v.index(), [&]( auto I ){
+
+        return get<I>(v) <= get<I>(w);
+
+    });
+}
+
+template<class... T> constexpr bool operator>=( variant<T...> const & v, variant<T...> const & w )
+{
+    if( v.index() > w.index() ) return true;
+    if( v.index() < w.index() ) return false;
+
+    return mp_for_index<sizeof...(T)>( v.index(), [&]( auto I ){
+
+        return get<I>(v) >= get<I>(w);
+
+    });
+}
+
+// visitation
+template<class F> constexpr auto visit( F&& f ) -> decltype(std::forward<F>(f)())
+{
+    return std::forward<F>(f)();
+}
+
+namespace detail
+{
+
+template<class T> using remove_cv_ref = std::remove_cv_t<std::remove_reference_t<T>>;
+
+template<class F> struct Qret
+{
+    template<class... T> using fn = decltype( std::declval<F>()( std::declval<T>()... ) );
+};
+
+template<class L> using front_if_same = mp_if<mp_apply<mp_same, L>, mp_front<L>>;
+
+template<class F, class... V> using Vret = front_if_same<mp_product_q<Qret<F>, remove_cv_ref<V>...>>;
+
+} // namespace detail
+
+template<class F, class V1> constexpr auto visit( F&& f, V1&& v1 ) -> variant2::detail::Vret<F, V1>
+{
+    return mp_for_index<mp_size<variant2::detail::remove_cv_ref<V1>>>( v1.index(), [&]( auto I ){
+
+        return std::forward<F>(f)( get<I>( std::forward<V1>(v1) ) );
+
+    });
+}
+
+#if BOOST_WORKAROUND( BOOST_MSVC, <= 1910 )
+
+template<class F, class V1, class V2> constexpr auto visit( F&& f, V1&& v1, V2&& v2 ) -> variant2::detail::Vret<F, V1, V2>
+{
+    return mp_for_index<mp_size<variant2::detail::remove_cv_ref<V1>>>( v1.index(), [&]( auto I ){
+
+        auto f2 = [&]( auto&&... a ){ return std::forward<F>(f)( get<I.value>( std::forward<V1>(v1) ), std::forward<decltype(a)>(a)... ); };
+        return visit( f2, std::forward<V2>(v2) );
+
+    });
+}
+
+template<class F, class V1, class V2, class V3> constexpr auto visit( F&& f, V1&& v1, V2&& v2, V3&& v3 ) -> variant2::detail::Vret<F, V1, V2, V3>
+{
+    return mp_for_index<mp_size<variant2::detail::remove_cv_ref<V1>>>( v1.index(), [&]( auto I ){
+
+        auto f2 = [&]( auto&&... a ){ return std::forward<F>(f)( get<I.value>( std::forward<V1>(v1) ), std::forward<decltype(a)>(a)... ); };
+        return visit( f2, std::forward<V2>(v2), std::forward<V3>(v3) );
+
+    });
+}
+
+template<class F, class V1, class V2, class V3, class V4> constexpr auto visit( F&& f, V1&& v1, V2&& v2, V3&& v3, V4&& v4 ) -> variant2::detail::Vret<F, V1, V2, V3, V4>
+{
+    return mp_for_index<mp_size<variant2::detail::remove_cv_ref<V1>>>( v1.index(), [&]( auto I ){
+
+        auto f2 = [&]( auto&&... a ){ return std::forward<F>(f)( get<I.value>( std::forward<V1>(v1) ), std::forward<decltype(a)>(a)... ); };
+        return visit( f2, std::forward<V2>(v2), std::forward<V3>(v3), std::forward<V4>(v4) );
+
+    });
+}
+
+#else
+
+template<class F, class V1, class V2, class... V> constexpr auto visit( F&& f, V1&& v1, V2&& v2, V&&... v ) -> variant2::detail::Vret<F, V1, V2, V...>
+{
+    return mp_for_index<mp_size<variant2::detail::remove_cv_ref<V1>>>( v1.index(), [&]( auto I ){
+
+        auto f2 = [&]( auto&&... a ){ return std::forward<F>(f)( get<I.value>( std::forward<V1>(v1) ), std::forward<decltype(a)>(a)... ); };
+        return visit( f2, std::forward<V2>(v2), std::forward<V>(v)... );
+
+    });
+}
+
+#endif
+
+// specialized algorithms
+template<class... T,
+    class E = std::enable_if_t<mp_all<std::is_move_constructible<T>..., variant2::detail::is_swappable<T>...>::value>>
+void swap( variant<T...> & v, variant<T...> & w )
+    noexcept( noexcept(v.swap(w)) )
+{
+    v.swap( w );
+}
+
+} // namespace variant2
+} // namespace boost
+
+#endif // #ifndef BOOST_VARIANT2_VARIANT_HPP_INCLUDED
diff --git a/meta/libraries.json b/meta/libraries.json
new file mode 100644
index 0000000..50915a9
--- /dev/null
+++ b/meta/libraries.json
@@ -0,0 +1,14 @@
+{
+    "key": "variant2",
+    "name": "Variant2",
+    "authors": [
+        "Peter Dimov"
+    ],
+    "maintainers": [
+        "Peter Dimov <pdimov -at- pdimov.com>"
+    ],
+    "description": "A never-valueless implementation of std::variant.",
+    "category": [
+        "Containers", "Data"
+    ]
+}
diff --git a/test/Jamfile b/test/Jamfile
new file mode 100644
index 0000000..4a68bfe
--- /dev/null
+++ b/test/Jamfile
@@ -0,0 +1,40 @@
+#  Boost.Variant2 Library Test Jamfile
+#
+#  Copyright 2015-2017 Peter Dimov
+#
+#  Distributed under the Boost Software License, Version 1.0.
+#  See accompanying file LICENSE_1_0.txt or copy at
+#  http://www.boost.org/LICENSE_1_0.txt
+
+import testing ;
+import ../../config/checks/config : requires ;
+
+REQ = ; #[ requires cxx11_variadic_templates cxx11_template_aliases cxx11_decltype cxx11_hdr_type_traits ] ;
+
+run variant_size.cpp : : : $(REQ) ;
+run variant_alternative.cpp : : : $(REQ) ;
+run variant_holds_alternative.cpp : : : $(REQ) ;
+compile variant_holds_alternative_cx.cpp : : : $(REQ) ;
+run variant_get_by_index.cpp : : : $(REQ) ;
+compile variant_get_by_index_cx.cpp : : : $(REQ) ;
+run variant_get_by_type.cpp : : : $(REQ) ;
+compile variant_get_by_type_cx.cpp : : : $(REQ) ;
+run variant_default_construct.cpp : : : $(REQ) ;
+compile variant_default_construct_cx.cpp : : : $(REQ) ;
+run variant_copy_construct.cpp : : : $(REQ) ;
+run variant_move_construct.cpp : : : $(REQ) ;
+run variant_value_construct.cpp : : : $(REQ) ;
+compile variant_value_construct_cx.cpp : : : $(REQ) ;
+run variant_in_place_index_construct.cpp : : : $(REQ) ;
+compile variant_in_place_index_construct_cx.cpp : : : $(REQ) ;
+run variant_in_place_type_construct.cpp : : : $(REQ) ;
+compile variant_in_place_type_construct_cx.cpp : : : $(REQ) ;
+run variant_copy_assign.cpp : : : $(REQ) ;
+run variant_move_assign.cpp : : : $(REQ) ;
+run variant_value_assign.cpp : : : $(REQ) ;
+run variant_emplace_index.cpp : : : $(REQ) ;
+run variant_emplace_type.cpp : : : $(REQ) ;
+run variant_swap.cpp : : : $(REQ) ;
+run variant_eq_ne.cpp : : : $(REQ) ;
+run variant_destroy.cpp : : : $(REQ) ;
+run variant_visit.cpp : : : $(REQ) ;
diff --git a/test/variant_alternative.cpp b/test/variant_alternative.cpp
new file mode 100644
index 0000000..e5a9fa7
--- /dev/null
+++ b/test/variant_alternative.cpp
@@ -0,0 +1,89 @@
+
+// Copyright 2017 Peter Dimov.
+//
+// Distributed under the Boost Software License, Version 1.0.
+//
+// See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/variant2/variant.hpp>
+#include <boost/mp11.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+#include <cstddef>
+
+using namespace boost::variant2;
+using namespace boost::mp11;
+
+template<class I, class T> using var_alt_t = variant_alternative_t<I::value, T>;
+
+int main()
+{
+    BOOST_TEST_TRAIT_TRUE((std::is_same<variant_alternative_t<0, variant<void>>, void>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<variant_alternative_t<0, variant<void> const>, void const>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<variant_alternative_t<0, variant<void> volatile>, void volatile>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<variant_alternative_t<0, variant<void> const volatile>, void const volatile>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<variant_alternative_t<0, variant<void, int>>, void>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<variant_alternative_t<0, variant<void, int> const>, void const>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<variant_alternative_t<0, variant<void, int> volatile>, void volatile>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<variant_alternative_t<0, variant<void, int> const volatile>, void const volatile>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<variant_alternative_t<1, variant<void, int>>, int>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<variant_alternative_t<1, variant<void, int> const>, int const>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<variant_alternative_t<1, variant<void, int> volatile>, int volatile>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<variant_alternative_t<1, variant<void, int> const volatile>, int const volatile>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<variant_alternative_t<0, variant<void, int, float>>, void>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<variant_alternative_t<0, variant<void, int, float> const>, void const>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<variant_alternative_t<0, variant<void, int, float> volatile>, void volatile>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<variant_alternative_t<0, variant<void, int, float> const volatile>, void const volatile>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<variant_alternative_t<1, variant<void, int, float>>, int>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<variant_alternative_t<1, variant<void, int, float> const>, int const>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<variant_alternative_t<1, variant<void, int, float> volatile>, int volatile>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<variant_alternative_t<1, variant<void, int, float> const volatile>, int const volatile>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<variant_alternative_t<2, variant<void, int, float>>, float>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<variant_alternative_t<2, variant<void, int, float> const>, float const>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<variant_alternative_t<2, variant<void, int, float> volatile>, float volatile>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<variant_alternative_t<2, variant<void, int, float> const volatile>, float const volatile>));
+
+    variant_alternative<0, void>();
+    variant_alternative<0, void const>();
+    variant_alternative<0, void volatile>();
+    variant_alternative<0, void const volatile>();
+
+    variant_alternative<0, variant<>>();
+    variant_alternative<0, variant<> const>();
+    variant_alternative<0, variant<> volatile>();
+    variant_alternative<0, variant<> const volatile>();
+
+    variant_alternative<1, variant<int>>();
+    variant_alternative<1, variant<int> const>();
+    variant_alternative<1, variant<int> volatile>();
+    variant_alternative<1, variant<int> const volatile>();
+
+    BOOST_TEST_TRAIT_FALSE((mp_valid<var_alt_t, mp_size_t<0>, void>));
+    BOOST_TEST_TRAIT_FALSE((mp_valid<var_alt_t, mp_size_t<0>, void const>));
+    BOOST_TEST_TRAIT_FALSE((mp_valid<var_alt_t, mp_size_t<0>, void volatile>));
+    BOOST_TEST_TRAIT_FALSE((mp_valid<var_alt_t, mp_size_t<0>, void const volatile>));
+
+    BOOST_TEST_TRAIT_FALSE((mp_valid<var_alt_t, mp_size_t<0>, variant<>>));
+    BOOST_TEST_TRAIT_FALSE((mp_valid<var_alt_t, mp_size_t<0>, variant<> const>));
+    BOOST_TEST_TRAIT_FALSE((mp_valid<var_alt_t, mp_size_t<0>, variant<> volatile>));
+    BOOST_TEST_TRAIT_FALSE((mp_valid<var_alt_t, mp_size_t<0>, variant<> const volatile>));
+
+    BOOST_TEST_TRAIT_TRUE((mp_valid<var_alt_t, mp_size_t<0>, variant<int>>));
+    BOOST_TEST_TRAIT_TRUE((mp_valid<var_alt_t, mp_size_t<0>, variant<int> const>));
+    BOOST_TEST_TRAIT_TRUE((mp_valid<var_alt_t, mp_size_t<0>, variant<int> volatile>));
+    BOOST_TEST_TRAIT_TRUE((mp_valid<var_alt_t, mp_size_t<0>, variant<int> const volatile>));
+
+    BOOST_TEST_TRAIT_FALSE((mp_valid<var_alt_t, mp_size_t<1>, variant<int>>));
+    BOOST_TEST_TRAIT_FALSE((mp_valid<var_alt_t, mp_size_t<1>, variant<int> const>));
+    BOOST_TEST_TRAIT_FALSE((mp_valid<var_alt_t, mp_size_t<1>, variant<int> volatile>));
+    BOOST_TEST_TRAIT_FALSE((mp_valid<var_alt_t, mp_size_t<1>, variant<int> const volatile>));
+
+    return boost::report_errors();
+}
diff --git a/test/variant_copy_assign.cpp b/test/variant_copy_assign.cpp
new file mode 100644
index 0000000..c4ae80f
--- /dev/null
+++ b/test/variant_copy_assign.cpp
@@ -0,0 +1,194 @@
+
+// Copyright 2017 Peter Dimov.
+//
+// Distributed under the Boost Software License, Version 1.0.
+//
+// See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/variant2/variant.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+#include <utility>
+#include <string>
+
+using namespace boost::variant2;
+
+#define STATIC_ASSERT(...) static_assert(__VA_ARGS__, #__VA_ARGS__)
+
+struct X1
+{
+    int v;
+
+    X1(): v(0) {}
+    explicit X1(int v): v(v) {}
+    X1(X1 const& r): v(r.v) {}
+    X1(X1&& r): v(r.v) {}
+    X1& operator=( X1 const& r ) { v = r.v; return *this; }
+    X1& operator=( X1&& r ) { v = r.v; return *this; }
+};
+
+inline bool operator==( X1 const& a, X1 const& b ) { return a.v == b.v; }
+
+STATIC_ASSERT( !std::is_nothrow_default_constructible<X1>::value );
+STATIC_ASSERT( !std::is_nothrow_copy_constructible<X1>::value );
+STATIC_ASSERT( !std::is_nothrow_move_constructible<X1>::value );
+STATIC_ASSERT( !std::is_nothrow_copy_assignable<X1>::value );
+STATIC_ASSERT( !std::is_nothrow_move_assignable<X1>::value );
+
+struct X2
+{
+    int v;
+
+    X2(): v(0) {}
+    explicit X2(int v): v(v) {}
+    X2(X2 const& r): v(r.v) {}
+    X2(X2&& r): v(r.v) {}
+    X2& operator=( X2 const& r ) { v = r.v; return *this; }
+    X2& operator=( X2&& r ) { v = r.v; return *this; }
+};
+
+inline bool operator==( X2 const& a, X2 const& b ) { return a.v == b.v; }
+
+STATIC_ASSERT( !std::is_nothrow_default_constructible<X2>::value );
+STATIC_ASSERT( !std::is_nothrow_copy_constructible<X2>::value );
+STATIC_ASSERT( !std::is_nothrow_move_constructible<X2>::value );
+STATIC_ASSERT( !std::is_nothrow_copy_assignable<X2>::value );
+STATIC_ASSERT( !std::is_nothrow_move_assignable<X2>::value );
+
+struct Y
+{
+    Y& operator=( Y const& ) = delete;
+};
+
+int main()
+{
+    {
+        variant<int> v;
+        BOOST_TEST_EQ( get<0>(v), 0 );
+
+        variant<int> v2( 1 );
+
+        v = v2;
+        BOOST_TEST_EQ( get<0>(v), 1 );
+
+        variant<int> const v3( 2 );
+
+        v = v3;
+        BOOST_TEST_EQ( get<0>(v), 2 );
+    }
+
+    {
+        variant<int, float> v;
+        BOOST_TEST_EQ( v.index(), 0 );
+        BOOST_TEST_EQ( get<0>(v), 0 );
+
+        variant<int, float> v2( 1 );
+
+        v = v2;
+        BOOST_TEST_EQ( v.index(), 0 );
+        BOOST_TEST_EQ( get<0>(v), 1 );
+
+        variant<int, float> v3( 3.14f );
+
+        v = v3;
+        BOOST_TEST_EQ( v.index(), 1 );
+        BOOST_TEST_EQ( get<1>(v), 3.14f );
+
+        variant<int, float> const v4( 3.15f );
+
+        v = v4;
+        BOOST_TEST_EQ( v.index(), 1 );
+        BOOST_TEST_EQ( get<1>(v), 3.15f );
+    }
+
+    {
+        variant<int, int, float, std::string> v;
+        BOOST_TEST_EQ( v.index(), 0 );
+        BOOST_TEST_EQ( get<0>(v), 0 );
+
+        variant<int, int, float, std::string> v2( in_place_index<1>, 1 );
+
+        v = v2;
+        BOOST_TEST_EQ( v.index(), 1 );
+        BOOST_TEST_EQ( get<1>(v), 1 );
+
+        variant<int, int, float, std::string> v3( 3.14f );
+
+        v = v3;
+        BOOST_TEST_EQ( v.index(), 2 );
+        BOOST_TEST_EQ( get<2>(v), 3.14f );
+
+        variant<int, int, float, std::string> const v4( 3.15f );
+
+        v = v4;
+        BOOST_TEST_EQ( v.index(), 2 );
+        BOOST_TEST_EQ( get<2>(v), 3.15f );
+
+        variant<int, int, float, std::string> v5( "s1" );
+
+        v = v5;
+        BOOST_TEST_EQ( v.index(), 3 );
+        BOOST_TEST_EQ( get<3>(v), std::string("s1") );
+
+        variant<int, int, float, std::string> const v6( "s2" );
+
+        v = v6;
+        BOOST_TEST_EQ( v.index(), 3 );
+        BOOST_TEST_EQ( get<3>(v), std::string("s2") );
+    }
+
+    {
+        variant<X1, X2> v;
+        BOOST_TEST_EQ( v.index(), 0 );
+        BOOST_TEST_EQ( get<0>(v).v, 0 );
+
+        variant<X1, X2> v2( X1{1} );
+
+        v = v2;
+        BOOST_TEST_EQ( v.index(), 0 );
+        BOOST_TEST_EQ( get<0>(v).v, 1 );
+
+        variant<X1, X2> v3( in_place_index<1>, 2 );
+
+        v = v3;
+        BOOST_TEST_EQ( v.index(), 1 );
+        BOOST_TEST_EQ( get<1>(v).v, 2 );
+
+        variant<X1, X2> const v4( in_place_index<1>, 3 );
+
+        v = v4;
+        BOOST_TEST_EQ( v.index(), 1 );
+        BOOST_TEST_EQ( get<1>(v).v, 3 );
+
+        variant<X1, X2> const v5( in_place_index<0>, 4 );
+
+        v = v5;
+        BOOST_TEST_EQ( v.index(), 0 );
+        BOOST_TEST_EQ( get<0>(v).v, 4 );
+    }
+
+    {
+        BOOST_TEST_TRAIT_TRUE((std::is_nothrow_copy_assignable<variant<int>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_nothrow_copy_assignable<variant<int, int>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_nothrow_copy_assignable<variant<int, float>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_nothrow_copy_assignable<variant<int, int, float, float>>));
+
+        BOOST_TEST_TRAIT_FALSE((std::is_nothrow_copy_assignable<variant<X1>>));
+        BOOST_TEST_TRAIT_FALSE((std::is_nothrow_copy_assignable<variant<X1, int>>));
+        BOOST_TEST_TRAIT_FALSE((std::is_nothrow_copy_assignable<variant<X1, int, float>>));
+
+        BOOST_TEST_TRAIT_FALSE((std::is_nothrow_copy_assignable<variant<int, X1>>));
+        BOOST_TEST_TRAIT_FALSE((std::is_nothrow_copy_assignable<variant<int, int, X1>>));
+
+        BOOST_TEST_TRAIT_FALSE((std::is_nothrow_copy_assignable<variant<X1, X2>>));
+        BOOST_TEST_TRAIT_FALSE((std::is_nothrow_copy_assignable<variant<X1, X2, int, int>>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_copy_assignable<variant<X1, X2>>));
+        BOOST_TEST_TRAIT_FALSE((std::is_copy_assignable<variant<int const>>));
+        BOOST_TEST_TRAIT_FALSE((std::is_copy_assignable<variant<int, float, Y>>));
+    }
+
+    return boost::report_errors();
+}
diff --git a/test/variant_copy_construct.cpp b/test/variant_copy_construct.cpp
new file mode 100644
index 0000000..473d8a2
--- /dev/null
+++ b/test/variant_copy_construct.cpp
@@ -0,0 +1,128 @@
+
+// Copyright 2017 Peter Dimov.
+//
+// Distributed under the Boost Software License, Version 1.0.
+//
+// See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/variant2/variant.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+#include <utility>
+#include <string>
+
+using namespace boost::variant2;
+
+#define STATIC_ASSERT(...) static_assert(__VA_ARGS__, #__VA_ARGS__)
+
+struct X1
+{
+    X1() {}
+    X1(X1 const&) {}
+    X1(X1&&) {}
+};
+
+inline bool operator==( X1, X1 ) { return true; }
+
+STATIC_ASSERT( !std::is_nothrow_default_constructible<X1>::value );
+STATIC_ASSERT( !std::is_nothrow_copy_constructible<X1>::value );
+STATIC_ASSERT( !std::is_nothrow_move_constructible<X1>::value );
+
+struct X2
+{
+    X2() {}
+    X2(X2 const&) {}
+    X2(X2&&) {}
+};
+
+inline bool operator==( X2, X2 ) { return true; }
+
+STATIC_ASSERT( !std::is_nothrow_default_constructible<X2>::value );
+STATIC_ASSERT( !std::is_nothrow_copy_constructible<X2>::value );
+STATIC_ASSERT( !std::is_nothrow_move_constructible<X2>::value );
+
+struct Y
+{
+    Y( Y const& ) = delete;
+};
+
+template<class V> static void test( V const & v )
+{
+    V v2( v );
+
+    BOOST_TEST_EQ( v.index(), v2.index() );
+    BOOST_TEST( v == v2 );
+}
+
+int main()
+{
+    test( variant<int>() );
+    test( variant<int>(1) );
+
+    test( variant<int const>() );
+    test( variant<int const>(1) );
+
+    test( variant<int, float>() );
+    test( variant<int, float>(1) );
+    test( variant<int, float>(3.14f) );
+
+    test( variant<int, float, std::string>() );
+    test( variant<int, float, std::string>(1) );
+    test( variant<int, float, std::string>(3.14f) );
+    test( variant<int, float, std::string>("test") );
+
+    test( variant<int, int>() );
+
+    test( variant<int, int, float>() );
+    test( variant<int, int, float>(3.14f) );
+
+    test( variant<int, int, float, float>() );
+
+    test( variant<int, int, float, float, std::string>("test") );
+
+    test( variant<std::string, std::string, float>() );
+
+    test( variant<X1, X2>() );
+    test( variant<X1, X2, int>() );
+    test( variant<X1, X2, X2>() );
+    test( variant<X1, X1, X2, X2>() );
+
+    {
+        variant<X1, X2> v;
+        v.emplace<X2>();
+
+        test( v );
+    }
+
+    {
+        variant<X1, X1, X2> v;
+        v.emplace<X2>();
+
+        test( v );
+    }
+
+    {
+        BOOST_TEST_TRAIT_TRUE((std::is_nothrow_copy_constructible<variant<int>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_nothrow_copy_constructible<variant<int const>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_nothrow_copy_constructible<variant<int, int>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_nothrow_copy_constructible<variant<int, float>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_nothrow_copy_constructible<variant<int, int, float, float>>));
+
+        BOOST_TEST_TRAIT_FALSE((std::is_nothrow_copy_constructible<variant<X1>>));
+        BOOST_TEST_TRAIT_FALSE((std::is_nothrow_copy_constructible<variant<X1, int>>));
+        BOOST_TEST_TRAIT_FALSE((std::is_nothrow_copy_constructible<variant<X1, int, float>>));
+
+        BOOST_TEST_TRAIT_FALSE((std::is_nothrow_copy_constructible<variant<int, X1>>));
+        BOOST_TEST_TRAIT_FALSE((std::is_nothrow_copy_constructible<variant<int, int, X1>>));
+
+        BOOST_TEST_TRAIT_FALSE((std::is_nothrow_copy_constructible<variant<X1, X2>>));
+        BOOST_TEST_TRAIT_FALSE((std::is_nothrow_copy_constructible<variant<X1, X2, int, int>>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_copy_constructible<variant<X1, X2>>));
+        BOOST_TEST_TRAIT_FALSE((std::is_copy_constructible<variant<int, float, Y>>));
+    }
+
+    return boost::report_errors();
+}
diff --git a/test/variant_default_construct.cpp b/test/variant_default_construct.cpp
new file mode 100644
index 0000000..894934c
--- /dev/null
+++ b/test/variant_default_construct.cpp
@@ -0,0 +1,103 @@
+
+// Copyright 2017 Peter Dimov.
+//
+// Distributed under the Boost Software License, Version 1.0.
+//
+// See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/variant2/variant.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+#include <utility>
+#include <string>
+
+using namespace boost::variant2;
+
+struct X
+{
+    X();
+};
+
+struct Y
+{
+    Y() = delete;
+};
+
+int main()
+{
+    {
+        variant<int> v;
+
+        BOOST_TEST_EQ( v.index(), 0 );
+        BOOST_TEST_EQ( get<0>(v), 0 );
+    }
+
+    {
+        variant<int const> v;
+
+        BOOST_TEST_EQ( v.index(), 0 );
+        BOOST_TEST_EQ( get<0>(v), 0 );
+    }
+
+    {
+        variant<int, float, std::string> v;
+
+        BOOST_TEST_EQ( v.index(), 0 );
+        BOOST_TEST_EQ( get<0>(v), 0 );
+    }
+
+    {
+        variant<int, int, std::string> v;
+
+        BOOST_TEST_EQ( v.index(), 0 );
+        BOOST_TEST_EQ( get<0>(v), 0 );
+    }
+
+    {
+        variant<std::string> v;
+
+        BOOST_TEST_EQ( v.index(), 0 );
+        BOOST_TEST_EQ( get<0>(v), std::string() );
+    }
+
+    {
+        variant<std::string const> v;
+
+        BOOST_TEST_EQ( v.index(), 0 );
+        BOOST_TEST_EQ( get<0>(v), std::string() );
+    }
+
+    {
+        variant<std::string, int, float> v;
+
+        BOOST_TEST_EQ( v.index(), 0 );
+        BOOST_TEST_EQ( get<0>(v), std::string() );
+    }
+
+    {
+        variant<std::string, std::string, float> v;
+
+        BOOST_TEST_EQ( v.index(), 0 );
+        BOOST_TEST_EQ( get<0>(v), std::string() );
+    }
+
+    {
+        BOOST_TEST_TRAIT_TRUE((std::is_nothrow_default_constructible<variant<int>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_nothrow_default_constructible<variant<int const>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_nothrow_default_constructible<variant<int, X>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_nothrow_default_constructible<variant<int, float, X>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_nothrow_default_constructible<variant<int, int, X>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_nothrow_default_constructible<variant<int, X, X>>));
+
+        BOOST_TEST_TRAIT_FALSE((std::is_nothrow_default_constructible<variant<X>>));
+        BOOST_TEST_TRAIT_FALSE((std::is_nothrow_default_constructible<variant<X, int>>));
+        BOOST_TEST_TRAIT_FALSE((std::is_nothrow_default_constructible<variant<X, int, float>>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_default_constructible<variant<int, Y>>));
+        BOOST_TEST_TRAIT_FALSE((std::is_default_constructible<variant<Y, int>>));
+    }
+
+    return boost::report_errors();
+}
diff --git a/test/variant_default_construct_cx.cpp b/test/variant_default_construct_cx.cpp
new file mode 100644
index 0000000..d3325c6
--- /dev/null
+++ b/test/variant_default_construct_cx.cpp
@@ -0,0 +1,51 @@
+
+// Copyright 2017 Peter Dimov.
+//
+// Distributed under the Boost Software License, Version 1.0.
+//
+// See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/variant2/variant.hpp>
+
+using namespace boost::variant2;
+
+#define STATIC_ASSERT(...) static_assert(__VA_ARGS__, #__VA_ARGS__)
+
+int main()
+{
+    {
+        constexpr variant<int> v;
+
+        STATIC_ASSERT( v.index() == 0 );
+        STATIC_ASSERT( get<0>(v) == 0 );
+    }
+
+    {
+        constexpr variant<int const> v;
+
+        STATIC_ASSERT( v.index() == 0 );
+        STATIC_ASSERT( get<0>(v) == 0 );
+    }
+
+    {
+        constexpr variant<int, float> v;
+
+        STATIC_ASSERT( v.index() == 0 );
+        STATIC_ASSERT( get<0>(v) == 0 );
+    }
+
+    {
+        constexpr variant<int, int, float> v;
+
+        STATIC_ASSERT( v.index() == 0 );
+        STATIC_ASSERT( get<0>(v) == 0 );
+    }
+
+    {
+        constexpr variant<int, float, float> v;
+
+        STATIC_ASSERT( v.index() == 0 );
+        STATIC_ASSERT( get<0>(v) == 0 );
+    }
+}
diff --git a/test/variant_destroy.cpp b/test/variant_destroy.cpp
new file mode 100644
index 0000000..392a2d7
--- /dev/null
+++ b/test/variant_destroy.cpp
@@ -0,0 +1,205 @@
+
+// Copyright 2017 Peter Dimov.
+//
+// Distributed under the Boost Software License, Version 1.0.
+//
+// See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/variant2/variant.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+#include <utility>
+#include <string>
+
+using namespace boost::variant2;
+
+struct X1
+{
+    static int instances;
+
+    int v;
+
+    X1(): v(0) { ++instances; }
+    explicit X1(int v): v(v) { ++instances; }
+    X1(X1 const& r): v(r.v) { ++instances; }
+    X1(X1&& r): v(r.v) { ++instances; }
+
+    ~X1() noexcept { --instances; }
+
+    X1& operator=( X1 const& r ) { v = r.v; return *this; }
+    X1& operator=( X1&& r ) { v = r.v; return *this; }
+};
+
+int X1::instances = 0;
+
+struct X2
+{
+    static int instances;
+
+    int v;
+
+    X2(): v(0) { ++instances; }
+    explicit X2(int v): v(v) { ++instances; }
+    X2(X2 const& r): v(r.v) { ++instances; }
+    X2(X2&& r): v(r.v) { ++instances; }
+
+    ~X2() noexcept { --instances; }
+
+    X2& operator=( X2 const& r ) { v = r.v; return *this; }
+    X2& operator=( X2&& r ) { v = r.v; return *this; }
+};
+
+int X2::instances = 0;
+
+struct Y1
+{
+    static int instances;
+
+    int v;
+
+    Y1() noexcept: v(0) { ++instances; }
+    explicit Y1(int v) noexcept: v(v) { ++instances; }
+    Y1(Y1 const& r) noexcept: v(r.v) { ++instances; }
+    Y1(Y1&& r) noexcept: v(r.v) { ++instances; }
+
+    ~Y1() noexcept { --instances; }
+
+    Y1& operator=( Y1 const& r ) noexcept { v = r.v; return *this; }
+    Y1& operator=( Y1&& r ) noexcept { v = r.v; return *this; }
+};
+
+int Y1::instances = 0;
+
+struct Y2
+{
+    static int instances;
+
+    int v;
+
+    Y2() noexcept: v(0) { ++instances; }
+    explicit Y2(int v) noexcept: v(v) { ++instances; }
+    Y2(Y2 const& r) noexcept: v(r.v) { ++instances; }
+    Y2(Y2&& r) noexcept: v(r.v) { ++instances; }
+
+    ~Y2() noexcept { --instances; }
+
+    Y2& operator=( Y2 const& r ) noexcept { v = r.v; return *this; }
+    Y2& operator=( Y2&& r ) noexcept { v = r.v; return *this; }
+};
+
+int Y2::instances = 0;
+
+int main()
+{
+    BOOST_TEST_EQ( Y1::instances, 0 );
+
+    {
+        variant<Y1> v;
+        BOOST_TEST_EQ( Y1::instances, 1 );
+
+        {
+            variant<Y1> v2;
+            BOOST_TEST_EQ( Y1::instances, 2 );
+
+            v = v2;
+            BOOST_TEST_EQ( Y1::instances, 2 );
+        }
+
+        BOOST_TEST_EQ( Y1::instances, 1 );
+
+        v = Y1{1};
+        BOOST_TEST_EQ( Y1::instances, 1 );
+    }
+
+    BOOST_TEST_EQ( Y1::instances, 0 );
+    BOOST_TEST_EQ( Y2::instances, 0 );
+
+    {
+        variant<Y1, Y2> v;
+
+        BOOST_TEST_EQ( Y1::instances, 1 );
+        BOOST_TEST_EQ( Y2::instances, 0 );
+
+        {
+            variant<Y1, Y2> v2;
+            BOOST_TEST_EQ( Y1::instances, 2 );
+            BOOST_TEST_EQ( Y2::instances, 0 );
+
+            v = v2;
+            BOOST_TEST_EQ( Y1::instances, 2 );
+            BOOST_TEST_EQ( Y2::instances, 0 );
+
+            v2 = Y2{1};
+            BOOST_TEST_EQ( Y1::instances, 1 );
+            BOOST_TEST_EQ( Y2::instances, 1 );
+
+            v = v2;
+            BOOST_TEST_EQ( Y1::instances, 0 );
+            BOOST_TEST_EQ( Y2::instances, 2 );
+        }
+
+        BOOST_TEST_EQ( Y1::instances, 0 );
+        BOOST_TEST_EQ( Y2::instances, 1 );
+
+        v.emplace<0>();
+
+        BOOST_TEST_EQ( Y1::instances, 1 );
+        BOOST_TEST_EQ( Y2::instances, 0 );
+
+        v.emplace<Y2>();
+
+        BOOST_TEST_EQ( Y1::instances, 0 );
+        BOOST_TEST_EQ( Y2::instances, 1 );
+    }
+
+    BOOST_TEST_EQ( Y1::instances, 0 );
+    BOOST_TEST_EQ( Y2::instances, 0 );
+
+    BOOST_TEST_EQ( X1::instances, 0 );
+    BOOST_TEST_EQ( X2::instances, 0 );
+
+    {
+        variant<X1, X2> v;
+
+        BOOST_TEST_EQ( X1::instances, 1 );
+        BOOST_TEST_EQ( X2::instances, 0 );
+
+        {
+            variant<X1, X2> v2;
+            BOOST_TEST_EQ( X1::instances, 2 );
+            BOOST_TEST_EQ( X2::instances, 0 );
+
+            v = v2;
+            BOOST_TEST_EQ( X1::instances, 2 );
+            BOOST_TEST_EQ( X2::instances, 0 );
+
+            v2 = X2{1};
+            BOOST_TEST_EQ( X1::instances, 1 );
+            BOOST_TEST_EQ( X2::instances, 1 );
+
+            v = v2;
+            BOOST_TEST_EQ( X1::instances, 0 );
+            BOOST_TEST_EQ( X2::instances, 2 );
+        }
+
+        BOOST_TEST_EQ( X1::instances, 0 );
+        BOOST_TEST_EQ( X2::instances, 1 );
+
+        v.emplace<0>();
+
+        BOOST_TEST_EQ( X1::instances, 1 );
+        BOOST_TEST_EQ( X2::instances, 0 );
+
+        v.emplace<X2>();
+
+        BOOST_TEST_EQ( X1::instances, 0 );
+        BOOST_TEST_EQ( X2::instances, 1 );
+    }
+
+    BOOST_TEST_EQ( X1::instances, 0 );
+    BOOST_TEST_EQ( X2::instances, 0 );
+
+    return boost::report_errors();
+}
diff --git a/test/variant_emplace_index.cpp b/test/variant_emplace_index.cpp
new file mode 100644
index 0000000..7fa30b7
--- /dev/null
+++ b/test/variant_emplace_index.cpp
@@ -0,0 +1,181 @@
+
+// Copyright 2017 Peter Dimov.
+//
+// Distributed under the Boost Software License, Version 1.0.
+//
+// See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/variant2/variant.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+#include <utility>
+#include <string>
+
+using namespace boost::variant2;
+
+#define STATIC_ASSERT(...) static_assert(__VA_ARGS__, #__VA_ARGS__)
+
+struct X1
+{
+    int v;
+
+    X1(): v(0) {}
+    explicit X1(int v): v(v) {}
+    X1(X1 const& r): v(r.v) {}
+    X1(X1&& r): v(r.v) {}
+    X1& operator=( X1 const& r ) { v = r.v; return *this; }
+    X1& operator=( X1&& r ) { v = r.v; return *this; }
+};
+
+inline bool operator==( X1 const& a, X1 const& b ) { return a.v == b.v; }
+
+STATIC_ASSERT( !std::is_nothrow_default_constructible<X1>::value );
+STATIC_ASSERT( !std::is_nothrow_copy_constructible<X1>::value );
+STATIC_ASSERT( !std::is_nothrow_move_constructible<X1>::value );
+STATIC_ASSERT( !std::is_nothrow_copy_assignable<X1>::value );
+STATIC_ASSERT( !std::is_nothrow_move_assignable<X1>::value );
+
+struct X2
+{
+    int v;
+
+    X2(): v(0) {}
+    explicit X2(int v): v(v) {}
+    X2(X2 const& r): v(r.v) {}
+    X2(X2&& r): v(r.v) {}
+    X2& operator=( X2 const& r ) { v = r.v; return *this; }
+    X2& operator=( X2&& r ) { v = r.v; return *this; }
+};
+
+inline bool operator==( X2 const& a, X2 const& b ) { return a.v == b.v; }
+
+STATIC_ASSERT( !std::is_nothrow_default_constructible<X2>::value );
+STATIC_ASSERT( !std::is_nothrow_copy_constructible<X2>::value );
+STATIC_ASSERT( !std::is_nothrow_move_constructible<X2>::value );
+STATIC_ASSERT( !std::is_nothrow_copy_assignable<X2>::value );
+STATIC_ASSERT( !std::is_nothrow_move_assignable<X2>::value );
+
+int main()
+{
+    {
+        variant<int> v;
+        BOOST_TEST_EQ( get<0>(v), 0 );
+
+        v.emplace<0>( 1 );
+        BOOST_TEST_EQ( get<0>(v), 1 );
+
+        v.emplace<0>();
+        BOOST_TEST_EQ( get<0>(v), 0 );
+    }
+
+    {
+        variant<int, float> v;
+        BOOST_TEST_EQ( v.index(), 0 );
+        BOOST_TEST_EQ( get<0>(v), 0 );
+
+        v.emplace<0>( 1 );
+        BOOST_TEST_EQ( v.index(), 0 );
+        BOOST_TEST_EQ( get<0>(v), 1 );
+
+        v.emplace<1>( 3.14f );
+        BOOST_TEST_EQ( v.index(), 1 );
+        BOOST_TEST_EQ( get<1>(v), 3.14f );
+
+        v.emplace<1>();
+        BOOST_TEST_EQ( v.index(), 1 );
+        BOOST_TEST_EQ( get<1>(v), 0 );
+
+        v.emplace<0>();
+        BOOST_TEST_EQ( v.index(), 0 );
+        BOOST_TEST_EQ( get<0>(v), 0 );
+    }
+
+    {
+        variant<int, int, float, std::string> v;
+        BOOST_TEST_EQ( v.index(), 0 );
+        BOOST_TEST_EQ( get<0>(v), 0 );
+
+        v.emplace<0>( 1 );
+        BOOST_TEST_EQ( v.index(), 0 );
+        BOOST_TEST_EQ( get<0>(v), 1 );
+
+        v.emplace<1>();
+        BOOST_TEST_EQ( v.index(), 1 );
+        BOOST_TEST_EQ( get<1>(v), 0 );
+
+        v.emplace<1>( 1 );
+        BOOST_TEST_EQ( v.index(), 1 );
+        BOOST_TEST_EQ( get<1>(v), 1 );
+
+        v.emplace<2>( 3.14f );
+        BOOST_TEST_EQ( v.index(), 2 );
+        BOOST_TEST_EQ( get<2>(v), 3.14f );
+
+        v.emplace<2>();
+        BOOST_TEST_EQ( v.index(), 2 );
+        BOOST_TEST_EQ( get<2>(v), 0 );
+
+        v.emplace<3>( "s1" );
+        BOOST_TEST_EQ( v.index(), 3 );
+        BOOST_TEST_EQ( get<3>(v), std::string("s1") );
+
+        v.emplace<3>( "s2" );
+        BOOST_TEST_EQ( v.index(), 3 );
+        BOOST_TEST_EQ( get<3>(v), std::string("s2") );
+
+        v.emplace<3>();
+        BOOST_TEST_EQ( v.index(), 3 );
+        BOOST_TEST_EQ( get<3>(v), std::string() );
+
+        v.emplace<3>( { 'a', 'b' } );
+        BOOST_TEST_EQ( v.index(), 3 );
+        BOOST_TEST_EQ( get<3>(v), (std::string{ 'a', 'b'}) );
+
+        v.emplace<3>( { 'c', 'd' }, std::allocator<char>() );
+        BOOST_TEST_EQ( v.index(), 3 );
+        BOOST_TEST_EQ( get<3>(v), (std::string{ 'c', 'd'}) );
+    }
+
+    {
+        variant<X1, X2> v;
+        BOOST_TEST_EQ( v.index(), 0 );
+        BOOST_TEST_EQ( get<0>(v).v, 0 );
+
+        v.emplace<0>( 1 );
+        BOOST_TEST_EQ( v.index(), 0 );
+        BOOST_TEST_EQ( get<0>(v).v, 1 );
+
+        v.emplace<1>( 2 );
+        BOOST_TEST_EQ( v.index(), 1 );
+        BOOST_TEST_EQ( get<1>(v).v, 2 );
+
+        v.emplace<0>();
+        BOOST_TEST_EQ( v.index(), 0 );
+        BOOST_TEST_EQ( get<0>(v).v, 0 );
+
+        v.emplace<0>( 4 );
+        BOOST_TEST_EQ( v.index(), 0 );
+        BOOST_TEST_EQ( get<0>(v).v, 4 );
+
+        v.emplace<1>();
+
+        BOOST_TEST_EQ( v.index(), 1 );
+        BOOST_TEST_EQ( get<1>(v).v, 0 );
+
+        v.emplace<1>( 6 );
+        BOOST_TEST_EQ( v.index(), 1 );
+        BOOST_TEST_EQ( get<1>(v).v, 6 );
+
+        v.emplace<0>( 3 );
+        BOOST_TEST_EQ( v.index(), 0 );
+        BOOST_TEST_EQ( get<0>(v).v, 3 );
+
+        v.emplace<0>( 4 );
+        BOOST_TEST_EQ( v.index(), 0 );
+        BOOST_TEST_EQ( get<0>(v).v, 4 );
+    }
+
+    return boost::report_errors();
+}
diff --git a/test/variant_emplace_type.cpp b/test/variant_emplace_type.cpp
new file mode 100644
index 0000000..4189bbb
--- /dev/null
+++ b/test/variant_emplace_type.cpp
@@ -0,0 +1,169 @@
+
+// Copyright 2017 Peter Dimov.
+//
+// Distributed under the Boost Software License, Version 1.0.
+//
+// See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/variant2/variant.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+#include <utility>
+#include <string>
+
+using namespace boost::variant2;
+
+#define STATIC_ASSERT(...) static_assert(__VA_ARGS__, #__VA_ARGS__)
+
+struct X1
+{
+    int v;
+
+    X1(): v(0) {}
+    explicit X1(int v): v(v) {}
+    X1(X1 const& r): v(r.v) {}
+    X1(X1&& r): v(r.v) {}
+    X1& operator=( X1 const& r ) { v = r.v; return *this; }
+    X1& operator=( X1&& r ) { v = r.v; return *this; }
+};
+
+inline bool operator==( X1 const& a, X1 const& b ) { return a.v == b.v; }
+
+STATIC_ASSERT( !std::is_nothrow_default_constructible<X1>::value );
+STATIC_ASSERT( !std::is_nothrow_copy_constructible<X1>::value );
+STATIC_ASSERT( !std::is_nothrow_move_constructible<X1>::value );
+STATIC_ASSERT( !std::is_nothrow_copy_assignable<X1>::value );
+STATIC_ASSERT( !std::is_nothrow_move_assignable<X1>::value );
+
+struct X2
+{
+    int v;
+
+    X2(): v(0) {}
+    explicit X2(int v): v(v) {}
+    X2(X2 const& r): v(r.v) {}
+    X2(X2&& r): v(r.v) {}
+    X2& operator=( X2 const& r ) { v = r.v; return *this; }
+    X2& operator=( X2&& r ) { v = r.v; return *this; }
+};
+
+inline bool operator==( X2 const& a, X2 const& b ) { return a.v == b.v; }
+
+STATIC_ASSERT( !std::is_nothrow_default_constructible<X2>::value );
+STATIC_ASSERT( !std::is_nothrow_copy_constructible<X2>::value );
+STATIC_ASSERT( !std::is_nothrow_move_constructible<X2>::value );
+STATIC_ASSERT( !std::is_nothrow_copy_assignable<X2>::value );
+STATIC_ASSERT( !std::is_nothrow_move_assignable<X2>::value );
+
+int main()
+{
+    {
+        variant<int> v;
+        BOOST_TEST_EQ( get<0>(v), 0 );
+
+        v.emplace<int>( 1 );
+        BOOST_TEST_EQ( get<0>(v), 1 );
+
+        v.emplace<int>();
+        BOOST_TEST_EQ( get<0>(v), 0 );
+    }
+
+    {
+        variant<int, float> v;
+        BOOST_TEST_EQ( v.index(), 0 );
+        BOOST_TEST_EQ( get<0>(v), 0 );
+
+        v.emplace<int>( 1 );
+        BOOST_TEST_EQ( v.index(), 0 );
+        BOOST_TEST_EQ( get<0>(v), 1 );
+
+        v.emplace<float>( 3.14f );
+        BOOST_TEST_EQ( v.index(), 1 );
+        BOOST_TEST_EQ( get<1>(v), 3.14f );
+
+        v.emplace<float>();
+        BOOST_TEST_EQ( v.index(), 1 );
+        BOOST_TEST_EQ( get<1>(v), 0 );
+
+        v.emplace<int>();
+        BOOST_TEST_EQ( v.index(), 0 );
+        BOOST_TEST_EQ( get<0>(v), 0 );
+    }
+
+    {
+        variant<int, int, float, std::string> v;
+        BOOST_TEST_EQ( v.index(), 0 );
+        BOOST_TEST_EQ( get<0>(v), 0 );
+
+        v.emplace<float>( 3.14f );
+        BOOST_TEST_EQ( v.index(), 2 );
+        BOOST_TEST_EQ( get<2>(v), 3.14f );
+
+        v.emplace<float>();
+        BOOST_TEST_EQ( v.index(), 2 );
+        BOOST_TEST_EQ( get<2>(v), 0 );
+
+        v.emplace<std::string>( "s1" );
+        BOOST_TEST_EQ( v.index(), 3 );
+        BOOST_TEST_EQ( get<3>(v), std::string("s1") );
+
+        v.emplace<std::string>( "s2" );
+        BOOST_TEST_EQ( v.index(), 3 );
+        BOOST_TEST_EQ( get<3>(v), std::string("s2") );
+
+        v.emplace<std::string>();
+        BOOST_TEST_EQ( v.index(), 3 );
+        BOOST_TEST_EQ( get<3>(v), std::string() );
+
+        v.emplace<std::string>( { 'a', 'b' } );
+        BOOST_TEST_EQ( v.index(), 3 );
+        BOOST_TEST_EQ( get<3>(v), (std::string{ 'a', 'b' }) );
+
+        v.emplace<std::string>( { 'c', 'd' }, std::allocator<char>() );
+        BOOST_TEST_EQ( v.index(), 3 );
+        BOOST_TEST_EQ( get<3>(v), (std::string{ 'c', 'd' }) );
+    }
+
+    {
+        variant<X1, X2> v;
+        BOOST_TEST_EQ( v.index(), 0 );
+        BOOST_TEST_EQ( get<0>(v).v, 0 );
+
+        v.emplace<X1>( 1 );
+        BOOST_TEST_EQ( v.index(), 0 );
+        BOOST_TEST_EQ( get<0>(v).v, 1 );
+
+        v.emplace<X2>( 2 );
+        BOOST_TEST_EQ( v.index(), 1 );
+        BOOST_TEST_EQ( get<1>(v).v, 2 );
+
+        v.emplace<X1>();
+        BOOST_TEST_EQ( v.index(), 0 );
+        BOOST_TEST_EQ( get<0>(v).v, 0 );
+
+        v.emplace<X1>( 4 );
+        BOOST_TEST_EQ( v.index(), 0 );
+        BOOST_TEST_EQ( get<0>(v).v, 4 );
+
+        v.emplace<X2>();
+
+        BOOST_TEST_EQ( v.index(), 1 );
+        BOOST_TEST_EQ( get<1>(v).v, 0 );
+
+        v.emplace<X2>( 6 );
+        BOOST_TEST_EQ( v.index(), 1 );
+        BOOST_TEST_EQ( get<1>(v).v, 6 );
+
+        v.emplace<X1>( 3 );
+        BOOST_TEST_EQ( v.index(), 0 );
+        BOOST_TEST_EQ( get<0>(v).v, 3 );
+
+        v.emplace<X1>( 4 );
+        BOOST_TEST_EQ( v.index(), 0 );
+        BOOST_TEST_EQ( get<0>(v).v, 4 );
+    }
+
+    return boost::report_errors();
+}
diff --git a/test/variant_eq_ne.cpp b/test/variant_eq_ne.cpp
new file mode 100644
index 0000000..47b3873
--- /dev/null
+++ b/test/variant_eq_ne.cpp
@@ -0,0 +1,92 @@
+
+// Copyright 2017 Peter Dimov.
+//
+// Distributed under the Boost Software License, Version 1.0.
+//
+// See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/variant2/variant.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+#include <utility>
+#include <string>
+
+using namespace boost::variant2;
+
+struct X
+{
+};
+
+inline bool operator==( X const&, X const& ) { return false; }
+inline bool operator!=( X const&, X const& ) { return false; }
+
+int main()
+{
+    {
+        variant<int> v1, v2, v3( 1 ), v4( 1 );
+
+        BOOST_TEST( v1 == v2 );
+        BOOST_TEST_NOT( v1 != v2 );
+
+        BOOST_TEST( v1 != v3 );
+        BOOST_TEST_NOT( v1 == v3 );
+
+        BOOST_TEST( v3 == v4 );
+        BOOST_TEST_NOT( v3 != v4 );
+    }
+
+    {
+        variant<int, float> v1, v2, v3( 1 ), v4( 1 ), v5( 3.14f ), v6( 3.14f );
+
+        BOOST_TEST( v1 == v2 );
+        BOOST_TEST_NOT( v1 != v2 );
+
+        BOOST_TEST( v1 != v3 );
+        BOOST_TEST_NOT( v1 == v3 );
+
+        BOOST_TEST( v3 == v4 );
+        BOOST_TEST_NOT( v3 != v4 );
+
+        BOOST_TEST( v1 != v5 );
+        BOOST_TEST_NOT( v1 == v5 );
+
+        BOOST_TEST( v3 != v5 );
+        BOOST_TEST_NOT( v3 == v5 );
+
+        BOOST_TEST( v5 == v6 );
+        BOOST_TEST_NOT( v5 != v6 );
+    }
+
+    {
+        variant<int, int, float> v1, v2, v3( in_place_index<1> ), v4( in_place_index<1> ), v5( 3.14f ), v6( 3.14f );
+
+        BOOST_TEST( v1 == v2 );
+        BOOST_TEST_NOT( v1 != v2 );
+
+        BOOST_TEST( v1 != v3 );
+        BOOST_TEST_NOT( v1 == v3 );
+
+        BOOST_TEST( v3 == v4 );
+        BOOST_TEST_NOT( v3 != v4 );
+
+        BOOST_TEST( v1 != v5 );
+        BOOST_TEST_NOT( v1 == v5 );
+
+        BOOST_TEST( v3 != v5 );
+        BOOST_TEST_NOT( v3 == v5 );
+
+        BOOST_TEST( v5 == v6 );
+        BOOST_TEST_NOT( v5 != v6 );
+    }
+
+    {
+        variant<X> v1, v2;
+
+        BOOST_TEST_NOT( v1 == v2 );
+        BOOST_TEST_NOT( v1 != v2 );
+    }
+
+    return boost::report_errors();
+}
diff --git a/test/variant_get_by_index.cpp b/test/variant_get_by_index.cpp
new file mode 100644
index 0000000..b55313e
--- /dev/null
+++ b/test/variant_get_by_index.cpp
@@ -0,0 +1,200 @@
+
+// Copyright 2017 Peter Dimov.
+//
+// Distributed under the Boost Software License, Version 1.0.
+//
+// See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/variant2/variant.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+#include <utility>
+#include <string>
+
+using namespace boost::variant2;
+
+int main()
+{
+    {
+        variant<int> v;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype(get<0>(v)), int&>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype(get<0>(std::move(v))), int&&>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype(get_if<0>(&v)), int*>));
+    }
+
+    {
+        variant<int> const v;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype(get<0>(v)), int const&>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype(get<0>(std::move(v))), int const&&>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype(get_if<0>(&v)), int const*>));
+    }
+
+    {
+        variant<int const> v;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype(get<0>(v)), int const&>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype(get<0>(std::move(v))), int const&&>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype(get_if<0>(&v)), int const*>));
+    }
+
+    {
+        variant<int volatile> const v;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype(get<0>(v)), int const volatile&>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype(get<0>(std::move(v))), int const volatile&&>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype(get_if<0>(&v)), int const volatile*>));
+    }
+
+    {
+        variant<int> v;
+
+        BOOST_TEST_EQ( get<0>(v), 0 );
+        BOOST_TEST_EQ( get_if<0>(&v), &get<0>(v) );
+
+        BOOST_TEST_EQ( get<0>(std::move(v)), 0 );
+    }
+
+    {
+        variant<int> v( 1 );
+
+        BOOST_TEST_EQ( get<0>(v), 1 );
+        BOOST_TEST_EQ( get_if<0>(&v), &get<0>(v) );
+
+        BOOST_TEST_EQ( get<0>(std::move(v)), 1 );
+    }
+
+    {
+        variant<int, float> v;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype(get<0>(v)), int&>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype(get<0>(std::move(v))), int&&>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype(get_if<0>(&v)), int*>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype(get<1>(v)), float&>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype(get<1>(std::move(v))), float&&>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype(get_if<1>(&v)), float*>));
+    }
+
+    {
+        variant<int, float> const v;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype(get<0>(v)), int const&>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype(get<0>(std::move(v))), int const&&>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype(get_if<0>(&v)), int const*>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype(get<1>(v)), float const&>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype(get<1>(std::move(v))), float const&&>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype(get_if<1>(&v)), float const*>));
+    }
+
+    {
+        variant<int const, float volatile> v;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype(get<0>(v)), int const&>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype(get<0>(std::move(v))), int const&&>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype(get_if<0>(&v)), int const*>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype(get<1>(v)), float volatile&>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype(get<1>(std::move(v))), float volatile&&>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype(get_if<1>(&v)), float volatile*>));
+    }
+
+    {
+        variant<int const, float volatile> const v;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype(get<0>(v)), int const&>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype(get<0>(std::move(v))), int const&&>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype(get_if<0>(&v)), int const*>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype(get<1>(v)), float const volatile&>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype(get<1>(std::move(v))), float const volatile&&>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype(get_if<1>(&v)), float const volatile*>));
+    }
+
+    {
+        variant<int, float> v;
+
+        BOOST_TEST_EQ( get<0>(v), 0 );
+        BOOST_TEST_EQ( get_if<0>(&v), &get<0>(v) );
+
+        BOOST_TEST_THROWS( get<1>(v), bad_variant_access );
+        BOOST_TEST_EQ( get_if<1>(&v), nullptr );
+
+        BOOST_TEST_EQ( get<0>(std::move(v)), 0 );
+    }
+
+    {
+        variant<int, float> v( 1 );
+
+        BOOST_TEST_EQ( get<0>(v), 1 );
+        BOOST_TEST_EQ( get_if<0>(&v), &get<0>(v) );
+
+        BOOST_TEST_THROWS( get<1>(v), bad_variant_access );
+        BOOST_TEST_EQ( get_if<1>(&v), nullptr );
+
+        BOOST_TEST_EQ( get<0>(std::move(v)), 1 );
+    }
+
+    {
+        variant<int, float> v( 3.14f );
+
+        BOOST_TEST_THROWS( get<0>(v), bad_variant_access );
+        BOOST_TEST_EQ( get_if<0>(&v), nullptr );
+
+        BOOST_TEST_EQ( get<1>(v), 3.14f );
+        BOOST_TEST_EQ( get_if<1>(&v), &get<1>(v) );
+
+        BOOST_TEST_EQ( get<1>(std::move(v)), 3.14f );
+    }
+
+    {
+        variant<int, float, float> v;
+
+        BOOST_TEST_EQ( get<0>(v), 0 );
+        BOOST_TEST_EQ( get_if<0>(&v), &get<0>(v) );
+
+        BOOST_TEST_THROWS( get<1>(v), bad_variant_access );
+        BOOST_TEST_EQ( get_if<1>(&v), nullptr );
+
+        BOOST_TEST_THROWS( get<2>(v), bad_variant_access );
+        BOOST_TEST_EQ( get_if<2>(&v), nullptr );
+
+        BOOST_TEST_EQ( get<0>(std::move(v)), 0 );
+    }
+
+    {
+        variant<int, float, float> v( 1 );
+
+        BOOST_TEST_EQ( get<0>(v), 1 );
+        BOOST_TEST_EQ( get_if<0>(&v), &get<0>(v) );
+
+        BOOST_TEST_THROWS( get<1>(v), bad_variant_access );
+        BOOST_TEST_EQ( get_if<1>(&v), nullptr );
+
+        BOOST_TEST_THROWS( get<2>(v), bad_variant_access );
+        BOOST_TEST_EQ( get_if<2>(&v), nullptr );
+
+        BOOST_TEST_EQ( get<0>(std::move(v)), 1 );
+    }
+
+    {
+        variant<int, int, float> v( 3.14f );
+
+        BOOST_TEST_THROWS( get<0>(v), bad_variant_access );
+        BOOST_TEST_EQ( get_if<0>(&v), nullptr );
+
+        BOOST_TEST_THROWS( get<1>(v), bad_variant_access );
+        BOOST_TEST_EQ( get_if<1>(&v), nullptr );
+
+        BOOST_TEST_EQ( get<2>(v), 3.14f );
+        BOOST_TEST_EQ( get_if<2>(&v), &get<2>(v) );
+
+        BOOST_TEST_EQ( get<2>(std::move(v)), 3.14f );
+    }
+
+    return boost::report_errors();
+}
diff --git a/test/variant_get_by_index_cx.cpp b/test/variant_get_by_index_cx.cpp
new file mode 100644
index 0000000..ae1b99f
--- /dev/null
+++ b/test/variant_get_by_index_cx.cpp
@@ -0,0 +1,90 @@
+
+// Copyright 2017 Peter Dimov.
+//
+// Distributed under the Boost Software License, Version 1.0.
+//
+// See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/variant2/variant.hpp>
+
+using namespace boost::variant2;
+
+#define STATIC_ASSERT(...) static_assert(__VA_ARGS__, #__VA_ARGS__)
+
+int main()
+{
+    {
+        constexpr variant<int> v;
+
+        STATIC_ASSERT( get<0>(v) == 0 );
+        STATIC_ASSERT( get_if<0>(&v) == &get<0>(v) );
+    }
+
+    {
+        constexpr variant<int> v( 1 );
+
+        STATIC_ASSERT( get<0>(v) == 1 );
+        STATIC_ASSERT( get_if<0>(&v) == &get<0>(v) );
+    }
+
+    {
+        constexpr variant<int, float> v;
+
+        STATIC_ASSERT( get<0>(v) == 0 );
+        STATIC_ASSERT( get_if<0>(&v) == &get<0>(v) );
+
+        STATIC_ASSERT( get_if<1>(&v) == nullptr );
+    }
+
+    {
+        constexpr variant<int, float> v( 1 );
+
+        STATIC_ASSERT( get<0>(v) == 1 );
+        STATIC_ASSERT( get_if<0>(&v) == &get<0>(v) );
+
+        STATIC_ASSERT( get_if<1>(&v) == nullptr );
+    }
+
+    {
+        constexpr variant<int, float> v( 3.14f );
+
+        STATIC_ASSERT( get_if<0>(&v) == nullptr );
+
+        STATIC_ASSERT( get<1>(v) == 3.14f );
+        STATIC_ASSERT( get_if<1>(&v) == &get<1>(v) );
+    }
+
+    {
+        constexpr variant<int, float, float> v;
+
+        STATIC_ASSERT( get<0>(v) == 0 );
+        STATIC_ASSERT( get_if<0>(&v) == &get<0>(v) );
+
+        STATIC_ASSERT( get_if<1>(&v) == nullptr );
+
+        STATIC_ASSERT( get_if<2>(&v) == nullptr );
+    }
+
+    {
+        constexpr variant<int, float, float> v( 1 );
+
+        STATIC_ASSERT( get<0>(v) == 1 );
+        STATIC_ASSERT( get_if<0>(&v) == &get<0>(v) );
+
+        STATIC_ASSERT( get_if<1>(&v) == nullptr );
+
+        STATIC_ASSERT( get_if<2>(&v) == nullptr );
+    }
+
+    {
+        constexpr variant<int, int, float> v( 3.14f );
+
+        STATIC_ASSERT( get_if<0>(&v) == nullptr );
+
+        STATIC_ASSERT( get_if<1>(&v) == nullptr );
+
+        STATIC_ASSERT( get<2>(v) == 3.14f );
+        STATIC_ASSERT( get_if<2>(&v) == &get<2>(v) );
+    }
+}
diff --git a/test/variant_get_by_type.cpp b/test/variant_get_by_type.cpp
new file mode 100644
index 0000000..82b18c7
--- /dev/null
+++ b/test/variant_get_by_type.cpp
@@ -0,0 +1,166 @@
+
+// Copyright 2017 Peter Dimov.
+//
+// Distributed under the Boost Software License, Version 1.0.
+//
+// See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/variant2/variant.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+#include <utility>
+#include <string>
+
+using namespace boost::variant2;
+
+int main()
+{
+    {
+        variant<int> v;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype(get<int>(v)), int&>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype(get<int>(std::move(v))), int&&>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype(get_if<int>(&v)), int*>));
+    }
+
+    {
+        variant<int> const v;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype(get<int>(v)), int const&>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype(get<int>(std::move(v))), int const&&>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype(get_if<int>(&v)), int const*>));
+    }
+
+    {
+        variant<int const> v;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype(get<int const>(v)), int const&>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype(get<int const>(std::move(v))), int const&&>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype(get_if<int const>(&v)), int const*>));
+    }
+
+    {
+        variant<int volatile> const v;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype(get<int volatile>(v)), int const volatile&>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype(get<int volatile>(std::move(v))), int const volatile&&>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype(get_if<int volatile>(&v)), int const volatile*>));
+    }
+
+    {
+        variant<int> v;
+
+        BOOST_TEST_EQ( get<int>(v), 0 );
+        BOOST_TEST_EQ( get_if<int>(&v), &get<int>(v) );
+    }
+
+    {
+        variant<int> v( 1 );
+
+        BOOST_TEST_EQ( get<int>(v), 1 );
+        BOOST_TEST_EQ( get_if<int>(&v), &get<int>(v) );
+    }
+
+    {
+        variant<int, float> v;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype(get<int>(v)), int&>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype(get<int>(std::move(v))), int&&>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype(get_if<int>(&v)), int*>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype(get<float>(v)), float&>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype(get<float>(std::move(v))), float&&>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype(get_if<float>(&v)), float*>));
+    }
+
+    {
+        variant<int, float> const v;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype(get<int>(v)), int const&>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype(get<int>(std::move(v))), int const&&>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype(get_if<int>(&v)), int const*>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype(get<float>(v)), float const&>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype(get<float>(std::move(v))), float const&&>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype(get_if<float>(&v)), float const*>));
+    }
+
+    {
+        variant<int const, float volatile> v;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype(get<int const>(v)), int const&>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype(get<int const>(std::move(v))), int const&&>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype(get_if<int const>(&v)), int const*>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype(get<float volatile>(v)), float volatile&>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype(get<float volatile>(std::move(v))), float volatile&&>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype(get_if<float volatile>(&v)), float volatile*>));
+    }
+
+    {
+        variant<int const, float volatile> const v;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype(get<int const>(v)), int const&>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype(get<int const>(std::move(v))), int const&&>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype(get_if<int const>(&v)), int const*>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype(get<float volatile>(v)), float const volatile&>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype(get<float volatile>(std::move(v))), float const volatile&&>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<decltype(get_if<float volatile>(&v)), float const volatile*>));
+    }
+
+    {
+        variant<int, float> v;
+
+        BOOST_TEST_EQ( get<int>(v), 0 );
+        BOOST_TEST_EQ( get_if<int>(&v), &get<int>(v) );
+
+        BOOST_TEST_THROWS( get<float>(v), bad_variant_access );
+        BOOST_TEST_EQ( get_if<float>(&v), nullptr );
+    }
+
+    {
+        variant<int, float> v( 1 );
+
+        BOOST_TEST_EQ( get<int>(v), 1 );
+        BOOST_TEST_EQ( get_if<int>(&v), &get<int>(v) );
+
+        BOOST_TEST_THROWS( get<float>(v), bad_variant_access );
+        BOOST_TEST_EQ( get_if<float>(&v), nullptr );
+    }
+
+    {
+        variant<int, float> v( 3.14f );
+
+        BOOST_TEST_THROWS( get<int>(v), bad_variant_access );
+        BOOST_TEST_EQ( get_if<int>(&v), nullptr );
+
+        BOOST_TEST_EQ( get<float>(v), 3.14f );
+        BOOST_TEST_EQ( get_if<float>(&v), &get<float>(v) );
+    }
+
+    {
+        variant<int, float, float> v;
+
+        BOOST_TEST_EQ( get<int>(v), 0 );
+        BOOST_TEST_EQ( get_if<int>(&v), &get<int>(v) );
+    }
+
+    {
+        variant<int, float, float> v( 1 );
+
+        BOOST_TEST_EQ( get<int>(v), 1 );
+        BOOST_TEST_EQ( get_if<int>(&v), &get<int>(v) );
+    }
+
+    {
+        variant<int, int, float> v( 3.14f );
+
+        BOOST_TEST_EQ( get<float>(v), 3.14f );
+        BOOST_TEST_EQ( get_if<float>(&v), &get<float>(v) );
+    }
+
+    return boost::report_errors();
+}
diff --git a/test/variant_get_by_type_cx.cpp b/test/variant_get_by_type_cx.cpp
new file mode 100644
index 0000000..b4995fe
--- /dev/null
+++ b/test/variant_get_by_type_cx.cpp
@@ -0,0 +1,78 @@
+
+// Copyright 2017 Peter Dimov.
+//
+// Distributed under the Boost Software License, Version 1.0.
+//
+// See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/variant2/variant.hpp>
+
+using namespace boost::variant2;
+
+#define STATIC_ASSERT(...) static_assert(__VA_ARGS__, #__VA_ARGS__)
+
+int main()
+{
+    {
+        constexpr variant<int> v;
+
+        STATIC_ASSERT( get<int>(v) == 0 );
+        STATIC_ASSERT( get_if<int>(&v) == &get<int>(v) );
+    }
+
+    {
+        constexpr variant<int> v( 1 );
+
+        STATIC_ASSERT( get<int>(v) == 1 );
+        STATIC_ASSERT( get_if<int>(&v) == &get<int>(v) );
+    }
+
+    {
+        constexpr variant<int, float> v;
+
+        STATIC_ASSERT( get<int>(v) == 0 );
+        STATIC_ASSERT( get_if<int>(&v) == &get<int>(v) );
+
+        STATIC_ASSERT( get_if<float>(&v) == nullptr );
+    }
+
+    {
+        constexpr variant<int, float> v( 1 );
+
+        STATIC_ASSERT( get<int>(v) == 1 );
+        STATIC_ASSERT( get_if<int>(&v) == &get<int>(v) );
+
+        STATIC_ASSERT( get_if<float>(&v) == nullptr );
+    }
+
+    {
+        constexpr variant<int, float> v( 3.14f );
+
+        STATIC_ASSERT( get_if<int>(&v) == nullptr );
+
+        STATIC_ASSERT( get<float>(v) == 3.14f );
+        STATIC_ASSERT( get_if<float>(&v) == &get<float>(v) );
+    }
+
+    {
+        constexpr variant<int, float, float> v;
+
+        STATIC_ASSERT( get<int>(v) == 0 );
+        STATIC_ASSERT( get_if<int>(&v) == &get<int>(v) );
+    }
+
+    {
+        constexpr variant<int, float, float> v( 1 );
+
+        STATIC_ASSERT( get<int>(v) == 1 );
+        STATIC_ASSERT( get_if<int>(&v) == &get<int>(v) );
+    }
+
+    {
+        constexpr variant<int, int, float> v( 3.14f );
+
+        STATIC_ASSERT( get<float>(v) == 3.14f );
+        STATIC_ASSERT( get_if<float>(&v) == &get<float>(v) );
+    }
+}
diff --git a/test/variant_holds_alternative.cpp b/test/variant_holds_alternative.cpp
new file mode 100644
index 0000000..4931f40
--- /dev/null
+++ b/test/variant_holds_alternative.cpp
@@ -0,0 +1,78 @@
+
+// Copyright 2017 Peter Dimov.
+//
+// Distributed under the Boost Software License, Version 1.0.
+//
+// See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/variant2/variant.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <string>
+
+using namespace boost::variant2;
+
+int main()
+{
+    {
+        variant<int> v;
+        BOOST_TEST( holds_alternative<int>( v ) );
+    }
+
+    {
+        variant<int, float> v;
+        BOOST_TEST( holds_alternative<int>( v ) );
+        BOOST_TEST( !holds_alternative<float>( v ) );
+    }
+
+    {
+        variant<int, float> v( 3.14f );
+        BOOST_TEST( !holds_alternative<int>( v ) );
+        BOOST_TEST( holds_alternative<float>( v ) );
+    }
+
+    {
+        variant<int, float, float> v;
+        BOOST_TEST( holds_alternative<int>( v ) );
+    }
+
+    {
+        variant<int, int, float> v( 3.14f );
+        BOOST_TEST( holds_alternative<float>( v ) );
+    }
+
+    {
+        variant<int, float, std::string> v;
+        BOOST_TEST( holds_alternative<int>( v ) );
+        BOOST_TEST( !holds_alternative<float>( v ) );
+        BOOST_TEST( !holds_alternative<std::string>( v ) );
+    }
+
+    {
+        variant<int, float, std::string> v( 3.14f );
+        BOOST_TEST( !holds_alternative<int>( v ) );
+        BOOST_TEST( holds_alternative<float>( v ) );
+        BOOST_TEST( !holds_alternative<std::string>( v ) );
+    }
+
+    {
+        variant<int, float, std::string> v( "text" );
+        BOOST_TEST( !holds_alternative<int>( v ) );
+        BOOST_TEST( !holds_alternative<float>( v ) );
+        BOOST_TEST( holds_alternative<std::string>( v ) );
+    }
+
+    {
+        variant<int, int, float, std::string> v( 3.14f );
+        BOOST_TEST( holds_alternative<float>( v ) );
+        BOOST_TEST( !holds_alternative<std::string>( v ) );
+    }
+
+    {
+        variant<int, int, float, std::string> v( "text" );
+        BOOST_TEST( !holds_alternative<float>( v ) );
+        BOOST_TEST( holds_alternative<std::string>( v ) );
+    }
+
+    return boost::report_errors();
+}
diff --git a/test/variant_holds_alternative_cx.cpp b/test/variant_holds_alternative_cx.cpp
new file mode 100644
index 0000000..c2bdc0a
--- /dev/null
+++ b/test/variant_holds_alternative_cx.cpp
@@ -0,0 +1,43 @@
+
+// Copyright 2017 Peter Dimov.
+//
+// Distributed under the Boost Software License, Version 1.0.
+//
+// See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/variant2/variant.hpp>
+
+using namespace boost::variant2;
+
+#define STATIC_ASSERT(...) static_assert(__VA_ARGS__, #__VA_ARGS__)
+
+int main()
+{
+    {
+        constexpr variant<int> v;
+        STATIC_ASSERT( holds_alternative<int>( v ) );
+    }
+
+    {
+        constexpr variant<int, float> v;
+        STATIC_ASSERT( holds_alternative<int>( v ) );
+        STATIC_ASSERT( !holds_alternative<float>( v ) );
+    }
+
+    {
+        constexpr variant<int, float> v( 3.14f );
+        STATIC_ASSERT( !holds_alternative<int>( v ) );
+        STATIC_ASSERT( holds_alternative<float>( v ) );
+    }
+
+    {
+        constexpr variant<int, float, float> v;
+        STATIC_ASSERT( holds_alternative<int>( v ) );
+    }
+
+    {
+        constexpr variant<int, int, float> v( 3.14f );
+        STATIC_ASSERT( holds_alternative<float>( v ) );
+    }
+}
diff --git a/test/variant_in_place_index_construct.cpp b/test/variant_in_place_index_construct.cpp
new file mode 100644
index 0000000..4e87b3f
--- /dev/null
+++ b/test/variant_in_place_index_construct.cpp
@@ -0,0 +1,138 @@
+
+// Copyright 2017 Peter Dimov.
+//
+// Distributed under the Boost Software License, Version 1.0.
+//
+// See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/variant2/variant.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+#include <utility>
+#include <string>
+
+using namespace boost::variant2;
+
+struct X
+{
+    X() = default;
+    X( in_place_index_t<0> ) = delete;
+};
+
+int main()
+{
+    {
+        variant<int> v( in_place_index<0> );
+
+        BOOST_TEST_EQ( v.index(), 0 );
+        BOOST_TEST_EQ( get<0>(v), 0 );
+    }
+
+    {
+        variant<X> v( in_place_index<0> );
+
+        BOOST_TEST_EQ( v.index(), 0 );
+    }
+
+    {
+        variant<int> v( in_place_index<0>, 1 );
+
+        BOOST_TEST_EQ( v.index(), 0 );
+        BOOST_TEST_EQ( get<0>(v), 1 );
+    }
+
+    {
+        variant<int, float> v( in_place_index<0> );
+
+        BOOST_TEST_EQ( v.index(), 0 );
+        BOOST_TEST_EQ( get<0>(v), 0 );
+    }
+
+    {
+        variant<int, float> v( in_place_index<0>, 1 );
+
+        BOOST_TEST_EQ( v.index(), 0 );
+        BOOST_TEST_EQ( get<0>(v), 1 );
+    }
+
+    {
+        variant<int, float> v( in_place_index<1> );
+
+        BOOST_TEST_EQ( v.index(), 1 );
+        BOOST_TEST_EQ( get<1>(v), 0 );
+    }
+
+    {
+        variant<int, float> v( in_place_index<1>, 3.14f );
+
+        BOOST_TEST_EQ( v.index(), 1 );
+        BOOST_TEST_EQ( get<1>(v), 3.14f );
+    }
+
+    {
+        variant<int, int, float, float, std::string, std::string> v( in_place_index<0>, 1 );
+
+        BOOST_TEST_EQ( v.index(), 0 );
+        BOOST_TEST_EQ( get<0>(v), 1 );
+    }
+
+    {
+        variant<int, int, float, float, std::string, std::string> v( in_place_index<1>, 1 );
+
+        BOOST_TEST_EQ( v.index(), 1 );
+        BOOST_TEST_EQ( get<1>(v), 1 );
+    }
+
+    {
+        variant<int, int, float, float, std::string, std::string> v( in_place_index<2>, 3.14f );
+
+        BOOST_TEST_EQ( v.index(), 2 );
+        BOOST_TEST_EQ( get<2>(v), 3.14f );
+    }
+
+    {
+        variant<int, int, float, float, std::string, std::string> v( in_place_index<3>, 3.14f );
+
+        BOOST_TEST_EQ( v.index(), 3 );
+        BOOST_TEST_EQ( get<3>(v), 3.14f );
+    }
+
+    {
+        variant<int, int, float, float, std::string, std::string> v( in_place_index<4>, "text" );
+
+        BOOST_TEST_EQ( v.index(), 4 );
+        BOOST_TEST_EQ( get<4>(v), std::string("text") );
+    }
+
+    {
+        variant<int, int, float, float, std::string, std::string> v( in_place_index<5>, "text" );
+
+        BOOST_TEST_EQ( v.index(), 5 );
+        BOOST_TEST_EQ( get<5>(v), std::string("text") );
+    }
+
+    {
+        variant<int, int, float, float, std::string, std::string> v( in_place_index<5>, 4, 'a' );
+
+        BOOST_TEST_EQ( v.index(), 5 );
+        BOOST_TEST_EQ( get<5>(v), std::string( 4, 'a' ) );
+    }
+
+    {
+        variant<int, int, float, float, std::string, std::string> v( in_place_index<4>, { 'a', 'b', 'c' } );
+
+        BOOST_TEST_EQ( v.index(), 4 );
+        BOOST_TEST_EQ( get<4>(v), (std::string{ 'a', 'b', 'c' }) );
+    }
+
+    {
+        variant<int, int, float, float, std::string, std::string> v( in_place_index<5>, { 'a', 'b', 'c' }, std::allocator<char>() );
+
+        BOOST_TEST_EQ( v.index(), 5 );
+        BOOST_TEST_EQ( get<5>(v), (std::string{ 'a', 'b', 'c' }) );
+    }
+
+    return boost::report_errors();
+}
diff --git a/test/variant_in_place_index_construct_cx.cpp b/test/variant_in_place_index_construct_cx.cpp
new file mode 100644
index 0000000..e9c771f
--- /dev/null
+++ b/test/variant_in_place_index_construct_cx.cpp
@@ -0,0 +1,116 @@
+
+// Copyright 2017 Peter Dimov.
+//
+// Distributed under the Boost Software License, Version 1.0.
+//
+// See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/variant2/variant.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+#include <utility>
+#include <string>
+
+using namespace boost::variant2;
+
+struct X
+{
+    constexpr X() = default;
+    constexpr explicit X(int, int) {}
+    X( in_place_index_t<0> ) = delete;
+};
+
+#define STATIC_ASSERT(...) static_assert(__VA_ARGS__, #__VA_ARGS__)
+
+int main()
+{
+    {
+        constexpr variant<int> v( in_place_index<0> );
+
+        STATIC_ASSERT( v.index() == 0 );
+        STATIC_ASSERT( get<0>(v) == 0 );
+    }
+
+    {
+        constexpr variant<X> v( in_place_index<0> );
+
+        STATIC_ASSERT( v.index() == 0 );
+    }
+
+    {
+        constexpr variant<int> v( in_place_index<0>, 1 );
+
+        STATIC_ASSERT( v.index() == 0 );
+        STATIC_ASSERT( get<0>(v) == 1 );
+    }
+
+    {
+        constexpr variant<int, float> v( in_place_index<0> );
+
+        STATIC_ASSERT( v.index() == 0 );
+        STATIC_ASSERT( get<0>(v) == 0 );
+    }
+
+    {
+        constexpr variant<int, float> v( in_place_index<0>, 1 );
+
+        STATIC_ASSERT( v.index() == 0 );
+        STATIC_ASSERT( get<0>(v) == 1 );
+    }
+
+    {
+        constexpr variant<int, float> v( in_place_index<1> );
+
+        STATIC_ASSERT( v.index() == 1 );
+        STATIC_ASSERT( get<1>(v) == 0 );
+    }
+
+    {
+        constexpr variant<int, float> v( in_place_index<1>, 3.14f );
+
+        STATIC_ASSERT( v.index() == 1 );
+        STATIC_ASSERT( get<1>(v) == 3.14f );
+    }
+
+    {
+        constexpr variant<int, int, float, float, X, X> v( in_place_index<0>, 1 );
+
+        STATIC_ASSERT( v.index() == 0 );
+        STATIC_ASSERT( get<0>(v) == 1 );
+    }
+
+    {
+        constexpr variant<int, int, float, float, X, X> v( in_place_index<1>, 1 );
+
+        STATIC_ASSERT( v.index() == 1 );
+        STATIC_ASSERT( get<1>(v) == 1 );
+    }
+
+    {
+        constexpr variant<int, int, float, float, X, X> v( in_place_index<2>, 3.14f );
+
+        STATIC_ASSERT( v.index() == 2 );
+        STATIC_ASSERT( get<2>(v) == 3.14f );
+    }
+
+    {
+        constexpr variant<int, int, float, float, X, X> v( in_place_index<3>, 3.14f );
+
+        STATIC_ASSERT( v.index() == 3 );
+        STATIC_ASSERT( get<3>(v) == 3.14f );
+    }
+
+    {
+        constexpr variant<int, int, float, float, X, X> v( in_place_index<4> );
+
+        STATIC_ASSERT( v.index() == 4 );
+    }
+
+    {
+        constexpr variant<int, int, float, float, X, X> v( in_place_index<5>, 0, 0 );
+
+        STATIC_ASSERT( v.index() == 5 );
+    }
+}
diff --git a/test/variant_in_place_type_construct.cpp b/test/variant_in_place_type_construct.cpp
new file mode 100644
index 0000000..dc956eb
--- /dev/null
+++ b/test/variant_in_place_type_construct.cpp
@@ -0,0 +1,134 @@
+
+// Copyright 2017 Peter Dimov.
+//
+// Distributed under the Boost Software License, Version 1.0.
+//
+// See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/variant2/variant.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+#include <utility>
+#include <string>
+
+using namespace boost::variant2;
+
+struct X
+{
+    X() = default;
+    template<class T> X( in_place_type_t<T> ) = delete;
+};
+
+int main()
+{
+    {
+        variant<int> v( in_place_type<int> );
+
+        BOOST_TEST_EQ( v.index(), 0 );
+        BOOST_TEST_EQ( get<0>(v), 0 );
+
+        BOOST_TEST( holds_alternative<int>(v) );
+    }
+
+    {
+        variant<X> v( in_place_type<X> );
+
+        BOOST_TEST_EQ( v.index(), 0 );
+
+        BOOST_TEST( holds_alternative<X>(v) );
+    }
+
+    {
+        variant<int> v( in_place_type<int>, 1 );
+
+        BOOST_TEST_EQ( v.index(), 0 );
+        BOOST_TEST_EQ( get<0>(v), 1 );
+
+        BOOST_TEST( holds_alternative<int>(v) );
+    }
+
+    {
+        variant<int, float> v( in_place_type<int> );
+
+        BOOST_TEST_EQ( v.index(), 0 );
+        BOOST_TEST_EQ( get<0>(v), 0 );
+
+        BOOST_TEST( holds_alternative<int>(v) );
+    }
+
+    {
+        variant<int, float> v( in_place_type<int>, 1 );
+
+        BOOST_TEST_EQ( v.index(), 0 );
+        BOOST_TEST_EQ( get<0>(v), 1 );
+
+        BOOST_TEST( holds_alternative<int>(v) );
+    }
+
+    {
+        variant<int, float> v( in_place_type<float> );
+
+        BOOST_TEST_EQ( v.index(), 1 );
+        BOOST_TEST_EQ( get<1>(v), 0 );
+
+        BOOST_TEST( holds_alternative<float>(v) );
+    }
+
+    {
+        variant<int, float> v( in_place_type<float>, 3.14f );
+
+        BOOST_TEST_EQ( v.index(), 1 );
+        BOOST_TEST_EQ( get<1>(v), 3.14f );
+
+        BOOST_TEST( holds_alternative<float>(v) );
+    }
+
+    {
+        variant<int, int, float, std::string> v( in_place_type<float>, 3.14f );
+
+        BOOST_TEST_EQ( v.index(), 2 );
+        BOOST_TEST_EQ( get<2>(v), 3.14f );
+
+        BOOST_TEST( holds_alternative<float>(v) );
+    }
+
+    {
+        variant<int, int, float, float, std::string> v( in_place_type<std::string>, "text" );
+
+        BOOST_TEST_EQ( v.index(), 4 );
+        BOOST_TEST_EQ( get<4>(v), std::string("text") );
+
+        BOOST_TEST( holds_alternative<std::string>(v) );
+    }
+
+    {
+        variant<int, int, float, float, std::string> v( in_place_type<std::string>, 4, 'a' );
+
+        BOOST_TEST_EQ( v.index(), 4 );
+        BOOST_TEST_EQ( get<4>(v), std::string( 4, 'a' ) );
+
+        BOOST_TEST( holds_alternative<std::string>(v) );
+    }
+
+    {
+        variant<int, int, float, float, std::string> v( in_place_type<std::string>, { 'a', 'b', 'c' } );
+
+        BOOST_TEST_EQ( v.index(), 4 );
+        BOOST_TEST_EQ( get<4>(v), (std::string{ 'a', 'b', 'c' }) );
+
+        BOOST_TEST( holds_alternative<std::string>(v) );
+    }
+
+    {
+        variant<int, int, float, float, std::string> v( in_place_type<std::string>, { 'a', 'b', 'c' }, std::allocator<char>() );
+
+        BOOST_TEST_EQ( v.index(), 4 );
+        BOOST_TEST_EQ( get<4>(v), (std::string{ 'a', 'b', 'c' }) );
+
+        BOOST_TEST( holds_alternative<std::string>(v) );
+    }
+
+    return boost::report_errors();
+}
diff --git a/test/variant_in_place_type_construct_cx.cpp b/test/variant_in_place_type_construct_cx.cpp
new file mode 100644
index 0000000..054159b
--- /dev/null
+++ b/test/variant_in_place_type_construct_cx.cpp
@@ -0,0 +1,110 @@
+
+// Copyright 2017 Peter Dimov.
+//
+// Distributed under the Boost Software License, Version 1.0.
+//
+// See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/variant2/variant.hpp>
+
+using namespace boost::variant2;
+
+struct X
+{
+    constexpr X() = default;
+    constexpr explicit X(int, int) {}
+    template<class T> X( in_place_type_t<T> ) = delete;
+};
+
+#define STATIC_ASSERT(...) static_assert(__VA_ARGS__, #__VA_ARGS__)
+
+int main()
+{
+    {
+        constexpr variant<int> v( in_place_type<int> );
+
+        STATIC_ASSERT( v.index() == 0 );
+        STATIC_ASSERT( get<0>(v) == 0 );
+
+        STATIC_ASSERT( holds_alternative<int>(v) );
+    }
+
+    {
+        constexpr variant<X> v( in_place_type<X> );
+
+        STATIC_ASSERT( v.index() == 0 );
+
+        STATIC_ASSERT( holds_alternative<X>(v) );
+    }
+
+    {
+        constexpr variant<int> v( in_place_type<int>, 1 );
+
+        STATIC_ASSERT( v.index() == 0 );
+        STATIC_ASSERT( get<0>(v) == 1 );
+
+        STATIC_ASSERT( holds_alternative<int>(v) );
+    }
+
+    {
+        constexpr variant<int, float> v( in_place_type<int> );
+
+        STATIC_ASSERT( v.index() == 0 );
+        STATIC_ASSERT( get<0>(v) == 0 );
+
+        STATIC_ASSERT( holds_alternative<int>(v) );
+    }
+
+    {
+        constexpr variant<int, float> v( in_place_type<int>, 1 );
+
+        STATIC_ASSERT( v.index() == 0 );
+        STATIC_ASSERT( get<0>(v) == 1 );
+
+        STATIC_ASSERT( holds_alternative<int>(v) );
+    }
+
+    {
+        constexpr variant<int, float> v( in_place_type<float> );
+
+        STATIC_ASSERT( v.index() == 1 );
+        STATIC_ASSERT( get<1>(v) == 0 );
+
+        STATIC_ASSERT( holds_alternative<float>(v) );
+    }
+
+    {
+        constexpr variant<int, float> v( in_place_type<float>, 3.14f );
+
+        STATIC_ASSERT( v.index() == 1 );
+        STATIC_ASSERT( get<1>(v) == 3.14f );
+
+        STATIC_ASSERT( holds_alternative<float>(v) );
+    }
+
+    {
+        constexpr variant<int, int, float, X> v( in_place_type<float>, 3.14f );
+
+        STATIC_ASSERT( v.index() == 2 );
+        STATIC_ASSERT( get<2>(v) == 3.14f );
+
+        STATIC_ASSERT( holds_alternative<float>(v) );
+    }
+
+    {
+        constexpr variant<int, int, float, float, X> v( in_place_type<X> );
+
+        STATIC_ASSERT( v.index() == 4 );
+
+        STATIC_ASSERT( holds_alternative<X>(v) );
+    }
+
+    {
+        constexpr variant<int, int, float, float, X> v( in_place_type<X>, 0, 0 );
+
+        STATIC_ASSERT( v.index() == 4 );
+
+        STATIC_ASSERT( holds_alternative<X>(v) );
+    }
+}
diff --git a/test/variant_move_assign.cpp b/test/variant_move_assign.cpp
new file mode 100644
index 0000000..9c87718
--- /dev/null
+++ b/test/variant_move_assign.cpp
@@ -0,0 +1,194 @@
+
+// Copyright 2017 Peter Dimov.
+//
+// Distributed under the Boost Software License, Version 1.0.
+//
+// See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/variant2/variant.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+#include <utility>
+#include <string>
+
+using namespace boost::variant2;
+
+#define STATIC_ASSERT(...) static_assert(__VA_ARGS__, #__VA_ARGS__)
+
+struct X1
+{
+    int v;
+
+    X1(): v(0) {}
+    explicit X1(int v): v(v) {}
+    X1(X1 const& r): v(r.v) {}
+    X1(X1&& r): v(r.v) {}
+    X1& operator=( X1 const& r ) { v = r.v; return *this; }
+    X1& operator=( X1&& r ) { v = r.v; return *this; }
+};
+
+inline bool operator==( X1 const& a, X1 const& b ) { return a.v == b.v; }
+
+STATIC_ASSERT( !std::is_nothrow_default_constructible<X1>::value );
+STATIC_ASSERT( !std::is_nothrow_copy_constructible<X1>::value );
+STATIC_ASSERT( !std::is_nothrow_move_constructible<X1>::value );
+STATIC_ASSERT( !std::is_nothrow_copy_assignable<X1>::value );
+STATIC_ASSERT( !std::is_nothrow_move_assignable<X1>::value );
+
+struct X2
+{
+    int v;
+
+    X2(): v(0) {}
+    explicit X2(int v): v(v) {}
+    X2(X2 const& r): v(r.v) {}
+    X2(X2&& r): v(r.v) {}
+    X2& operator=( X2 const& r ) { v = r.v; return *this; }
+    X2& operator=( X2&& r ) { v = r.v; return *this; }
+};
+
+inline bool operator==( X2 const& a, X2 const& b ) { return a.v == b.v; }
+
+STATIC_ASSERT( !std::is_nothrow_default_constructible<X2>::value );
+STATIC_ASSERT( !std::is_nothrow_copy_constructible<X2>::value );
+STATIC_ASSERT( !std::is_nothrow_move_constructible<X2>::value );
+STATIC_ASSERT( !std::is_nothrow_copy_assignable<X2>::value );
+STATIC_ASSERT( !std::is_nothrow_move_assignable<X2>::value );
+
+struct Y
+{
+    Y& operator=( Y&& ) = delete;
+};
+
+int main()
+{
+    {
+        variant<int> v;
+        BOOST_TEST_EQ( get<0>(v), 0 );
+
+        variant<int> v2( 1 );
+
+        v = std::move(v2);
+        BOOST_TEST_EQ( get<0>(v), 1 );
+
+        variant<int> v3( 2 );
+
+        v = std::move(v3);
+        BOOST_TEST_EQ( get<0>(v), 2 );
+    }
+
+    {
+        variant<int, float> v;
+        BOOST_TEST_EQ( v.index(), 0 );
+        BOOST_TEST_EQ( get<0>(v), 0 );
+
+        variant<int, float> v2( 1 );
+
+        v = std::move(v2);
+        BOOST_TEST_EQ( v.index(), 0 );
+        BOOST_TEST_EQ( get<0>(v), 1 );
+
+        variant<int, float> v3( 3.14f );
+
+        v = std::move(v3);
+        BOOST_TEST_EQ( v.index(), 1 );
+        BOOST_TEST_EQ( get<1>(v), 3.14f );
+
+        variant<int, float> v4( 3.15f );
+
+        v = std::move(v4);
+        BOOST_TEST_EQ( v.index(), 1 );
+        BOOST_TEST_EQ( get<1>(v), 3.15f );
+    }
+
+    {
+        variant<int, int, float, std::string> v;
+        BOOST_TEST_EQ( v.index(), 0 );
+        BOOST_TEST_EQ( get<0>(v), 0 );
+
+        variant<int, int, float, std::string> v2( in_place_index<1>, 1 );
+
+        v = std::move(v2);
+        BOOST_TEST_EQ( v.index(), 1 );
+        BOOST_TEST_EQ( get<1>(v), 1 );
+
+        variant<int, int, float, std::string> v3( 3.14f );
+
+        v = std::move(v3);
+        BOOST_TEST_EQ( v.index(), 2 );
+        BOOST_TEST_EQ( get<2>(v), 3.14f );
+
+        variant<int, int, float, std::string> v4( 3.15f );
+
+        v = std::move(v4);
+        BOOST_TEST_EQ( v.index(), 2 );
+        BOOST_TEST_EQ( get<2>(v), 3.15f );
+
+        variant<int, int, float, std::string> v5( "s1" );
+
+        v = std::move(v5);
+        BOOST_TEST_EQ( v.index(), 3 );
+        BOOST_TEST_EQ( get<3>(v), std::string("s1") );
+
+        variant<int, int, float, std::string> v6( "s2" );
+
+        v = std::move(v6);
+        BOOST_TEST_EQ( v.index(), 3 );
+        BOOST_TEST_EQ( get<3>(v), std::string("s2") );
+    }
+
+    {
+        variant<X1, X2> v;
+        BOOST_TEST_EQ( v.index(), 0 );
+        BOOST_TEST_EQ( get<0>(v).v, 0 );
+
+        variant<X1, X2> v2( X1{1} );
+
+        v = std::move(v2);
+        BOOST_TEST_EQ( v.index(), 0 );
+        BOOST_TEST_EQ( get<0>(v).v, 1 );
+
+        variant<X1, X2> v3( in_place_index<1>, 2 );
+
+        v = std::move(v3);
+        BOOST_TEST_EQ( v.index(), 1 );
+        BOOST_TEST_EQ( get<1>(v).v, 2 );
+
+        variant<X1, X2> v4( in_place_index<1>, 3 );
+
+        v = std::move(v4);
+        BOOST_TEST_EQ( v.index(), 1 );
+        BOOST_TEST_EQ( get<1>(v).v, 3 );
+
+        variant<X1, X2> v5( in_place_index<0>, 4 );
+
+        v = std::move(v5);
+        BOOST_TEST_EQ( v.index(), 0 );
+        BOOST_TEST_EQ( get<0>(v).v, 4 );
+    }
+
+    {
+        BOOST_TEST_TRAIT_TRUE((std::is_nothrow_move_assignable<variant<int>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_nothrow_move_assignable<variant<int, int>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_nothrow_move_assignable<variant<int, float>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_nothrow_move_assignable<variant<int, int, float, float>>));
+
+        BOOST_TEST_TRAIT_FALSE((std::is_nothrow_move_assignable<variant<X1>>));
+        BOOST_TEST_TRAIT_FALSE((std::is_nothrow_move_assignable<variant<X1, int>>));
+        BOOST_TEST_TRAIT_FALSE((std::is_nothrow_move_assignable<variant<X1, int, float>>));
+
+        BOOST_TEST_TRAIT_FALSE((std::is_nothrow_move_assignable<variant<int, X1>>));
+        BOOST_TEST_TRAIT_FALSE((std::is_nothrow_move_assignable<variant<int, int, X1>>));
+
+        BOOST_TEST_TRAIT_FALSE((std::is_nothrow_move_assignable<variant<X1, X2>>));
+        BOOST_TEST_TRAIT_FALSE((std::is_nothrow_move_assignable<variant<X1, X2, int, int>>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_move_assignable<variant<X1, X2>>));
+        BOOST_TEST_TRAIT_FALSE((std::is_move_assignable<variant<int const>>));
+        BOOST_TEST_TRAIT_FALSE((std::is_move_assignable<variant<int, float, Y>>));
+    }
+
+    return boost::report_errors();
+}
diff --git a/test/variant_move_construct.cpp b/test/variant_move_construct.cpp
new file mode 100644
index 0000000..e3d8e98
--- /dev/null
+++ b/test/variant_move_construct.cpp
@@ -0,0 +1,129 @@
+
+// Copyright 2017 Peter Dimov.
+//
+// Distributed under the Boost Software License, Version 1.0.
+//
+// See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/variant2/variant.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+#include <utility>
+#include <string>
+
+using namespace boost::variant2;
+
+#define STATIC_ASSERT(...) static_assert(__VA_ARGS__, #__VA_ARGS__)
+
+struct X1
+{
+    X1() {}
+    X1(X1 const&) {}
+    X1(X1&&) {}
+};
+
+inline bool operator==( X1, X1 ) { return true; }
+
+STATIC_ASSERT( !std::is_nothrow_default_constructible<X1>::value );
+STATIC_ASSERT( !std::is_nothrow_copy_constructible<X1>::value );
+STATIC_ASSERT( !std::is_nothrow_move_constructible<X1>::value );
+
+struct X2
+{
+    X2() {}
+    X2(X2 const&) {}
+    X2(X2&&) {}
+};
+
+inline bool operator==( X2, X2 ) { return true; }
+
+STATIC_ASSERT( !std::is_nothrow_default_constructible<X2>::value );
+STATIC_ASSERT( !std::is_nothrow_copy_constructible<X2>::value );
+STATIC_ASSERT( !std::is_nothrow_move_constructible<X2>::value );
+
+struct Y
+{
+    Y( Y&& ) = delete;
+};
+
+template<class V> static void test( V&& v )
+{
+    V v2( v );
+    V v3( std::move(v) );
+
+    BOOST_TEST_EQ( v2.index(), v3.index() );
+    BOOST_TEST( v2 == v3 );
+}
+
+int main()
+{
+    test( variant<int>() );
+    test( variant<int>(1) );
+
+    test( variant<int const>() );
+    test( variant<int const>(1) );
+
+    test( variant<int, float>() );
+    test( variant<int, float>(1) );
+    test( variant<int, float>(3.14f) );
+
+    test( variant<int, float, std::string>() );
+    test( variant<int, float, std::string>(1) );
+    test( variant<int, float, std::string>(3.14f) );
+    test( variant<int, float, std::string>("test") );
+
+    test( variant<int, int>() );
+
+    test( variant<int, int, float>() );
+    test( variant<int, int, float>(3.14f) );
+
+    test( variant<int, int, float, float>() );
+
+    test( variant<int, int, float, float, std::string>("test") );
+
+    test( variant<std::string, std::string, float>() );
+
+    test( variant<X1, X2>() );
+    test( variant<X1, X2, int>() );
+    test( variant<X1, X2, X2>() );
+    test( variant<X1, X1, X2, X2>() );
+
+    {
+        variant<X1, X2> v;
+        v.emplace<X2>();
+
+        test( std::move(v) );
+    }
+
+    {
+        variant<X1, X1, X2> v;
+        v.emplace<X2>();
+
+        test( std::move(v) );
+    }
+
+    {
+        BOOST_TEST_TRAIT_TRUE((std::is_nothrow_move_constructible<variant<int>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_nothrow_move_constructible<variant<int const>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_nothrow_move_constructible<variant<int, int>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_nothrow_move_constructible<variant<int, float>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_nothrow_move_constructible<variant<int, int, float, float>>));
+
+        BOOST_TEST_TRAIT_FALSE((std::is_nothrow_move_constructible<variant<X1>>));
+        BOOST_TEST_TRAIT_FALSE((std::is_nothrow_move_constructible<variant<X1, int>>));
+        BOOST_TEST_TRAIT_FALSE((std::is_nothrow_move_constructible<variant<X1, int, float>>));
+
+        BOOST_TEST_TRAIT_FALSE((std::is_nothrow_move_constructible<variant<int, X1>>));
+        BOOST_TEST_TRAIT_FALSE((std::is_nothrow_move_constructible<variant<int, int, X1>>));
+
+        BOOST_TEST_TRAIT_FALSE((std::is_nothrow_move_constructible<variant<X1, X2>>));
+        BOOST_TEST_TRAIT_FALSE((std::is_nothrow_move_constructible<variant<X1, X2, int, int>>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_move_constructible<variant<X1, X2>>));
+        BOOST_TEST_TRAIT_FALSE((std::is_move_constructible<variant<int, float, Y>>));
+    }
+
+    return boost::report_errors();
+}
diff --git a/test/variant_size.cpp b/test/variant_size.cpp
new file mode 100644
index 0000000..b348418
--- /dev/null
+++ b/test/variant_size.cpp
@@ -0,0 +1,64 @@
+
+// Copyright 2017 Peter Dimov.
+//
+// Distributed under the Boost Software License, Version 1.0.
+//
+// See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/variant2/variant.hpp>
+#include <boost/mp11.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+#include <cstddef>
+
+using namespace boost::variant2;
+using namespace boost::mp11;
+
+template<class T> using var_size_t = mp_size_t<variant_size<T>::value>;
+
+int main()
+{
+    BOOST_TEST_EQ( (variant_size<variant<>>::value), 0 );
+    BOOST_TEST_EQ( (variant_size<variant<> const>::value), 0 );
+    BOOST_TEST_EQ( (variant_size<variant<> volatile>::value), 0 );
+    BOOST_TEST_EQ( (variant_size<variant<> const volatile>::value), 0 );
+
+    BOOST_TEST_EQ( (variant_size<variant<void>>::value), 1 );
+    BOOST_TEST_EQ( (variant_size<variant<void> const>::value), 1 );
+    BOOST_TEST_EQ( (variant_size<variant<void> volatile>::value), 1 );
+    BOOST_TEST_EQ( (variant_size<variant<void> const volatile>::value), 1 );
+
+    BOOST_TEST_EQ( (variant_size<variant<void, void>>::value), 2 );
+    BOOST_TEST_EQ( (variant_size<variant<void, void> const>::value), 2 );
+    BOOST_TEST_EQ( (variant_size<variant<void, void> volatile>::value), 2 );
+    BOOST_TEST_EQ( (variant_size<variant<void, void> const volatile>::value), 2 );
+
+    BOOST_TEST_EQ( (variant_size<variant<void, void, void>>::value), 3 );
+    BOOST_TEST_EQ( (variant_size<variant<void, void, void> const>::value), 3 );
+    BOOST_TEST_EQ( (variant_size<variant<void, void, void> volatile>::value), 3 );
+    BOOST_TEST_EQ( (variant_size<variant<void, void, void> const volatile>::value), 3 );
+
+    BOOST_TEST_EQ( (variant_size<variant<void, void, void, void>>::value), 4 );
+    BOOST_TEST_EQ( (variant_size<variant<void, void, void, void> const>::value), 4 );
+    BOOST_TEST_EQ( (variant_size<variant<void, void, void, void> volatile>::value), 4 );
+    BOOST_TEST_EQ( (variant_size<variant<void, void, void, void> const volatile>::value), 4 );
+
+    variant_size<void>();
+    variant_size<void const>();
+    variant_size<void volatile>();
+    variant_size<void const volatile>();
+
+    BOOST_TEST_TRAIT_FALSE((mp_valid<var_size_t, void>));
+    BOOST_TEST_TRAIT_FALSE((mp_valid<var_size_t, void const>));
+    BOOST_TEST_TRAIT_FALSE((mp_valid<var_size_t, void volatile>));
+    BOOST_TEST_TRAIT_FALSE((mp_valid<var_size_t, void const volatile>));
+
+    BOOST_TEST_TRAIT_TRUE((mp_valid<var_size_t, variant<>>));
+    BOOST_TEST_TRAIT_TRUE((mp_valid<var_size_t, variant<> const>));
+    BOOST_TEST_TRAIT_TRUE((mp_valid<var_size_t, variant<> volatile>));
+    BOOST_TEST_TRAIT_TRUE((mp_valid<var_size_t, variant<> const volatile>));
+
+    return boost::report_errors();
+}
diff --git a/test/variant_swap.cpp b/test/variant_swap.cpp
new file mode 100644
index 0000000..679f5f8
--- /dev/null
+++ b/test/variant_swap.cpp
@@ -0,0 +1,259 @@
+
+// Copyright 2017 Peter Dimov.
+//
+// Distributed under the Boost Software License, Version 1.0.
+//
+// See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/variant2/variant.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+#include <utility>
+#include <string>
+
+using namespace boost::variant2;
+
+#define STATIC_ASSERT(...) static_assert(__VA_ARGS__, #__VA_ARGS__)
+
+struct X1
+{
+    int v;
+
+    X1(): v(0) {}
+    explicit X1(int v): v(v) {}
+    X1(X1 const& r): v(r.v) {}
+    X1(X1&& r): v(r.v) {}
+    X1& operator=( X1 const& r ) { v = r.v; return *this; }
+    X1& operator=( X1&& r ) { v = r.v; return *this; }
+};
+
+inline bool operator==( X1 const& a, X1 const& b ) { return a.v == b.v; }
+
+STATIC_ASSERT( !std::is_nothrow_default_constructible<X1>::value );
+STATIC_ASSERT( !std::is_nothrow_copy_constructible<X1>::value );
+STATIC_ASSERT( !std::is_nothrow_move_constructible<X1>::value );
+STATIC_ASSERT( !std::is_nothrow_copy_assignable<X1>::value );
+STATIC_ASSERT( !std::is_nothrow_move_assignable<X1>::value );
+
+struct X2
+{
+    int v;
+
+    X2(): v(0) {}
+    explicit X2(int v): v(v) {}
+    X2(X2 const& r): v(r.v) {}
+    X2(X2&& r): v(r.v) {}
+    X2& operator=( X2 const& r ) { v = r.v; return *this; }
+    X2& operator=( X2&& r ) { v = r.v; return *this; }
+};
+
+inline bool operator==( X2 const& a, X2 const& b ) { return a.v == b.v; }
+
+STATIC_ASSERT( !std::is_nothrow_default_constructible<X2>::value );
+STATIC_ASSERT( !std::is_nothrow_copy_constructible<X2>::value );
+STATIC_ASSERT( !std::is_nothrow_move_constructible<X2>::value );
+STATIC_ASSERT( !std::is_nothrow_copy_assignable<X2>::value );
+STATIC_ASSERT( !std::is_nothrow_move_assignable<X2>::value );
+
+int main()
+{
+    {
+        variant<int> v;
+        BOOST_TEST_EQ( get<0>(v), 0 );
+
+        variant<int> v2( 1 );
+        BOOST_TEST_EQ( get<0>(v2), 1 );
+
+        swap( v, v2 );
+        BOOST_TEST_EQ( get<0>(v), 1 );
+        BOOST_TEST_EQ( get<0>(v2), 0 );
+
+        variant<int> v3( 2 );
+        BOOST_TEST_EQ( get<0>(v3), 2 );
+
+        swap( v, v3 );
+        BOOST_TEST_EQ( get<0>(v), 2 );
+        BOOST_TEST_EQ( get<0>(v3), 1 );
+    }
+
+    {
+        variant<int, float> v;
+
+        BOOST_TEST_EQ( v.index(), 0 );
+        BOOST_TEST_EQ( get<0>(v), 0 );
+
+        variant<int, float> v2( 1 );
+
+        BOOST_TEST_EQ( v2.index(), 0 );
+        BOOST_TEST_EQ( get<0>(v2), 1 );
+
+        swap( v, v2 );
+
+        BOOST_TEST_EQ( v.index(), 0 );
+        BOOST_TEST_EQ( get<0>(v), 1 );
+
+        BOOST_TEST_EQ( v2.index(), 0 );
+        BOOST_TEST_EQ( get<0>(v2), 0 );
+
+        variant<int, float> v3( 3.14f );
+
+        BOOST_TEST_EQ( v3.index(), 1 );
+        BOOST_TEST_EQ( get<1>(v3), 3.14f );
+
+        swap( v, v3 );
+
+        BOOST_TEST_EQ( v.index(), 1 );
+        BOOST_TEST_EQ( get<1>(v), 3.14f );
+
+        BOOST_TEST_EQ( v3.index(), 0 );
+        BOOST_TEST_EQ( get<0>(v3), 1 );
+
+        variant<int, float> v4( 3.15f );
+
+        BOOST_TEST_EQ( v4.index(), 1 );
+        BOOST_TEST_EQ( get<1>(v4), 3.15f );
+
+        swap( v, v4 );
+
+        BOOST_TEST_EQ( v.index(), 1 );
+        BOOST_TEST_EQ( get<1>(v), 3.15f );
+
+        BOOST_TEST_EQ( v4.index(), 1 );
+        BOOST_TEST_EQ( get<1>(v4), 3.14f );
+    }
+
+    {
+        variant<int, int, float, std::string> v;
+
+        BOOST_TEST_EQ( v.index(), 0 );
+        BOOST_TEST_EQ( get<0>(v), 0 );
+
+        variant<int, int, float, std::string> v2( in_place_index<1>, 1 );
+
+        BOOST_TEST_EQ( v2.index(), 1 );
+        BOOST_TEST_EQ( get<1>(v2), 1 );
+
+        swap( v, v2 );
+
+        BOOST_TEST_EQ( v.index(), 1 );
+        BOOST_TEST_EQ( get<1>(v), 1 );
+
+        BOOST_TEST_EQ( v2.index(), 0 );
+        BOOST_TEST_EQ( get<0>(v2), 0 );
+
+        variant<int, int, float, std::string> v3( 3.14f );
+
+        BOOST_TEST_EQ( v3.index(), 2 );
+        BOOST_TEST_EQ( get<2>(v3), 3.14f );
+
+        swap( v, v3 );
+
+        BOOST_TEST_EQ( v.index(), 2 );
+        BOOST_TEST_EQ( get<2>(v), 3.14f );
+
+        BOOST_TEST_EQ( v3.index(), 1 );
+        BOOST_TEST_EQ( get<1>(v3), 1 );
+
+        variant<int, int, float, std::string> v4( 3.15f );
+
+        BOOST_TEST_EQ( v4.index(), 2 );
+        BOOST_TEST_EQ( get<2>(v4), 3.15f );
+
+        swap( v, v4 );
+
+        BOOST_TEST_EQ( v.index(), 2 );
+        BOOST_TEST_EQ( get<2>(v), 3.15f );
+
+        BOOST_TEST_EQ( v4.index(), 2 );
+        BOOST_TEST_EQ( get<2>(v4), 3.14f );
+
+        variant<int, int, float, std::string> v5( "s1" );
+
+        BOOST_TEST_EQ( v5.index(), 3 );
+        BOOST_TEST_EQ( get<3>(v5), std::string("s1") );
+
+        swap( v, v5 );
+
+        BOOST_TEST_EQ( v.index(), 3 );
+        BOOST_TEST_EQ( get<3>(v), std::string("s1") );
+
+        BOOST_TEST_EQ( v5.index(), 2 );
+        BOOST_TEST_EQ( get<2>(v5), 3.15f );
+
+        variant<int, int, float, std::string> v6( "s2" );
+
+        BOOST_TEST_EQ( v6.index(), 3 );
+        BOOST_TEST_EQ( get<3>(v6), std::string("s2") );
+
+        swap( v, v6 );
+
+        BOOST_TEST_EQ( v.index(), 3 );
+        BOOST_TEST_EQ( get<3>(v), std::string("s2") );
+
+        BOOST_TEST_EQ( v6.index(), 3 );
+        BOOST_TEST_EQ( get<3>(v6), std::string("s1") );
+    }
+
+    {
+        variant<X1, X2> v;
+
+        BOOST_TEST_EQ( v.index(), 0 );
+        BOOST_TEST_EQ( get<0>(v).v, 0 );
+
+        variant<X1, X2> v2( X1{1} );
+
+        BOOST_TEST_EQ( v2.index(), 0 );
+        BOOST_TEST_EQ( get<0>(v2).v, 1 );
+
+        swap( v, v2 );
+
+        BOOST_TEST_EQ( v.index(), 0 );
+        BOOST_TEST_EQ( get<0>(v).v, 1 );
+
+        BOOST_TEST_EQ( v2.index(), 0 );
+        BOOST_TEST_EQ( get<0>(v2).v, 0 );
+
+        variant<X1, X2> v3( in_place_index<1>, 2 );
+
+        BOOST_TEST_EQ( v3.index(), 1 );
+        BOOST_TEST_EQ( get<1>(v3).v, 2 );
+
+        swap( v, v3 );
+
+        BOOST_TEST_EQ( v.index(), 1 );
+        BOOST_TEST_EQ( get<1>(v).v, 2 );
+
+        BOOST_TEST_EQ( v3.index(), 0 );
+        BOOST_TEST_EQ( get<0>(v3).v, 1 );
+
+        variant<X1, X2> v4( in_place_index<1>, 3 );
+
+        BOOST_TEST_EQ( v4.index(), 1 );
+        BOOST_TEST_EQ( get<1>(v4).v, 3 );
+
+        swap( v, v4 );
+
+        BOOST_TEST_EQ( v.index(), 1 );
+        BOOST_TEST_EQ( get<1>(v).v, 3 );
+
+        BOOST_TEST_EQ( v4.index(), 1 );
+        BOOST_TEST_EQ( get<1>(v4).v, 2 );
+
+        variant<X1, X2> v5( in_place_index<0>, 4 );
+
+        BOOST_TEST_EQ( v5.index(), 0 );
+        BOOST_TEST_EQ( get<0>(v5).v, 4 );
+
+        swap( v, v5 );
+
+        BOOST_TEST_EQ( v.index(), 0 );
+        BOOST_TEST_EQ( get<0>(v).v, 4 );
+
+        BOOST_TEST_EQ( v5.index(), 1 );
+        BOOST_TEST_EQ( get<1>(v5).v, 3 );
+    }
+
+    return boost::report_errors();
+}
diff --git a/test/variant_value_assign.cpp b/test/variant_value_assign.cpp
new file mode 100644
index 0000000..2519adc
--- /dev/null
+++ b/test/variant_value_assign.cpp
@@ -0,0 +1,206 @@
+
+// Copyright 2017 Peter Dimov.
+//
+// Distributed under the Boost Software License, Version 1.0.
+//
+// See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/variant2/variant.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+#include <utility>
+#include <string>
+
+using namespace boost::variant2;
+
+#define STATIC_ASSERT(...) static_assert(__VA_ARGS__, #__VA_ARGS__)
+
+struct X1
+{
+    int v;
+
+    X1(): v(0) {}
+    explicit X1(int v): v(v) {}
+    X1(X1 const& r): v(r.v) {}
+    X1(X1&& r): v(r.v) {}
+    X1& operator=( X1 const& r ) { v = r.v; return *this; }
+    X1& operator=( X1&& r ) { v = r.v; return *this; }
+};
+
+inline bool operator==( X1 const& a, X1 const& b ) { return a.v == b.v; }
+
+STATIC_ASSERT( !std::is_nothrow_default_constructible<X1>::value );
+STATIC_ASSERT( !std::is_nothrow_copy_constructible<X1>::value );
+STATIC_ASSERT( !std::is_nothrow_move_constructible<X1>::value );
+STATIC_ASSERT( !std::is_nothrow_copy_assignable<X1>::value );
+STATIC_ASSERT( !std::is_nothrow_move_assignable<X1>::value );
+
+struct X2
+{
+    int v;
+
+    X2(): v(0) {}
+    explicit X2(int v): v(v) {}
+    X2(X2 const& r): v(r.v) {}
+    X2(X2&& r): v(r.v) {}
+    X2& operator=( X2 const& r ) { v = r.v; return *this; }
+    X2& operator=( X2&& r ) { v = r.v; return *this; }
+};
+
+inline bool operator==( X2 const& a, X2 const& b ) { return a.v == b.v; }
+
+STATIC_ASSERT( !std::is_nothrow_default_constructible<X2>::value );
+STATIC_ASSERT( !std::is_nothrow_copy_constructible<X2>::value );
+STATIC_ASSERT( !std::is_nothrow_move_constructible<X2>::value );
+STATIC_ASSERT( !std::is_nothrow_copy_assignable<X2>::value );
+STATIC_ASSERT( !std::is_nothrow_move_assignable<X2>::value );
+
+int main()
+{
+    {
+        variant<int> v;
+        BOOST_TEST_EQ( get<0>(v), 0 );
+
+        v = 1;
+        BOOST_TEST_EQ( get<0>(v), 1 );
+
+        v = 2;
+        BOOST_TEST_EQ( get<0>(v), 2 );
+
+        int w1 = 3;
+
+        v = w1;
+        BOOST_TEST_EQ( get<0>(v), 3 );
+
+        int const w2 = 4;
+
+        v = w2;
+        BOOST_TEST_EQ( get<0>(v), 4 );
+
+        v = std::move( w1 );
+        BOOST_TEST_EQ( get<0>(v), 3 );
+
+        v = std::move( w2 );
+        BOOST_TEST_EQ( get<0>(v), 4 );
+    }
+
+    {
+        variant<int, float> v;
+        BOOST_TEST_EQ( v.index(), 0 );
+        BOOST_TEST_EQ( get<0>(v), 0 );
+
+        v = 1;
+        BOOST_TEST_EQ( v.index(), 0 );
+        BOOST_TEST_EQ( get<0>(v), 1 );
+
+        v = 3.14f;
+        BOOST_TEST_EQ( v.index(), 1 );
+        BOOST_TEST_EQ( get<1>(v), 3.14f );
+
+        float w1 = 3.15f;
+
+        v = w1;
+        BOOST_TEST_EQ( v.index(), 1 );
+        BOOST_TEST_EQ( get<1>(v), 3.15f );
+
+        int const w2 = 2;
+
+        v = w2;
+        BOOST_TEST_EQ( v.index(), 0 );
+        BOOST_TEST_EQ( get<0>(v), 2 );
+
+        v = std::move(w1);
+        BOOST_TEST_EQ( v.index(), 1 );
+        BOOST_TEST_EQ( get<1>(v), 3.15f );
+
+        v = std::move(w2);
+        BOOST_TEST_EQ( v.index(), 0 );
+        BOOST_TEST_EQ( get<0>(v), 2 );
+    }
+
+    {
+        variant<int, int, float, std::string> v;
+        BOOST_TEST_EQ( v.index(), 0 );
+        BOOST_TEST_EQ( get<0>(v), 0 );
+
+        v = 3.14f;
+        BOOST_TEST_EQ( v.index(), 2 );
+        BOOST_TEST_EQ( get<2>(v), 3.14f );
+
+        float const w1 = 3.15f;
+
+        v = w1;
+        BOOST_TEST_EQ( v.index(), 2 );
+        BOOST_TEST_EQ( get<2>(v), 3.15f );
+
+        variant<int, int, float, std::string> v5( "s1" );
+
+        v = "s1";
+        BOOST_TEST_EQ( v.index(), 3 );
+        BOOST_TEST_EQ( get<3>(v), std::string("s1") );
+
+        std::string w2( "s2" );
+
+        v = w2;
+        BOOST_TEST_EQ( v.index(), 3 );
+        BOOST_TEST_EQ( get<3>(v), std::string("s2") );
+
+        v = std::move(w1);
+        BOOST_TEST_EQ( v.index(), 2 );
+        BOOST_TEST_EQ( get<2>(v), 3.15f );
+
+        v = std::move(w2);
+        BOOST_TEST_EQ( v.index(), 3 );
+        BOOST_TEST_EQ( get<3>(v), std::string("s2") );
+    }
+
+    {
+        variant<X1, X2> v;
+        BOOST_TEST_EQ( v.index(), 0 );
+        BOOST_TEST_EQ( get<0>(v).v, 0 );
+
+        v = X1{1};
+        BOOST_TEST_EQ( v.index(), 0 );
+        BOOST_TEST_EQ( get<0>(v).v, 1 );
+
+        v = X2{2};
+        BOOST_TEST_EQ( v.index(), 1 );
+        BOOST_TEST_EQ( get<1>(v).v, 2 );
+
+        X1 w1{3};
+
+        v = w1;
+        BOOST_TEST_EQ( v.index(), 0 );
+        BOOST_TEST_EQ( get<0>(v).v, 3 );
+
+        X1 const w2{4};
+
+        v = w2;
+        BOOST_TEST_EQ( v.index(), 0 );
+        BOOST_TEST_EQ( get<0>(v).v, 4 );
+
+        X2 w3{5};
+
+        v = w3;
+        BOOST_TEST_EQ( v.index(), 1 );
+        BOOST_TEST_EQ( get<1>(v).v, 5 );
+
+        X2 const w4{6};
+
+        v = w4;
+        BOOST_TEST_EQ( v.index(), 1 );
+        BOOST_TEST_EQ( get<1>(v).v, 6 );
+
+        v = std::move(w1);
+        BOOST_TEST_EQ( v.index(), 0 );
+        BOOST_TEST_EQ( get<0>(v).v, 3 );
+
+        v = std::move(w2);
+        BOOST_TEST_EQ( v.index(), 0 );
+        BOOST_TEST_EQ( get<0>(v).v, 4 );
+    }
+
+    return boost::report_errors();
+}
diff --git a/test/variant_value_construct.cpp b/test/variant_value_construct.cpp
new file mode 100644
index 0000000..56df896
--- /dev/null
+++ b/test/variant_value_construct.cpp
@@ -0,0 +1,124 @@
+
+// Copyright 2017 Peter Dimov.
+//
+// Distributed under the Boost Software License, Version 1.0.
+//
+// See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/variant2/variant.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+#include <utility>
+#include <string>
+
+using namespace boost::variant2;
+
+struct X
+{
+    operator int() const { return 2; }
+};
+
+int main()
+{
+    {
+        variant<int> v( 1 );
+
+        BOOST_TEST_EQ( v.index(), 0 );
+        BOOST_TEST_EQ( get<0>(v), 1 );
+    }
+
+    {
+        variant<int> v( 'a' );
+
+        BOOST_TEST_EQ( v.index(), 0 );
+        BOOST_TEST_EQ( get<0>(v), 'a' );
+    }
+
+    {
+        variant<int> v( X{} );
+
+        BOOST_TEST_EQ( v.index(), 0 );
+        BOOST_TEST_EQ( get<0>(v), 2 );
+    }
+
+    {
+        variant<int const> v( 1 );
+
+        BOOST_TEST_EQ( v.index(), 0 );
+        BOOST_TEST_EQ( get<0>(v), 1 );
+    }
+
+    {
+        variant<int const> v( 'a' );
+
+        BOOST_TEST_EQ( v.index(), 0 );
+        BOOST_TEST_EQ( get<0>(v), 'a' );
+    }
+
+    {
+        variant<int const> v( X{} );
+
+        BOOST_TEST_EQ( v.index(), 0 );
+        BOOST_TEST_EQ( get<0>(v), 2 );
+    }
+
+    {
+        variant<int, float, std::string> v( 1 );
+
+        BOOST_TEST_EQ( v.index(), 0 );
+        BOOST_TEST( holds_alternative<int>(v) );
+        BOOST_TEST_EQ( get<0>(v), 1 );
+    }
+
+    {
+        variant<int, float, std::string> v( 'a' );
+
+        BOOST_TEST_EQ( v.index(), 0 );
+        BOOST_TEST( holds_alternative<int>(v) );
+        BOOST_TEST_EQ( get<0>(v), 'a' );
+    }
+
+    {
+        variant<int, float, std::string> v( X{} );
+
+        BOOST_TEST_EQ( v.index(), 0 );
+        BOOST_TEST( holds_alternative<int>(v) );
+        BOOST_TEST_EQ( get<0>(v), 2 );
+    }
+
+    {
+        variant<int, float, std::string> v( 3.14f );
+
+        BOOST_TEST_EQ( v.index(), 1 );
+        BOOST_TEST( holds_alternative<float>(v) );
+        BOOST_TEST_EQ( get<1>(v), 3.14f );
+    }
+
+    {
+        variant<int, float, std::string> v( "text" );
+
+        BOOST_TEST_EQ( v.index(), 2 );
+        BOOST_TEST( holds_alternative<std::string>(v) );
+        BOOST_TEST_EQ( get<2>(v), std::string("text") );
+    }
+
+    {
+        variant<int, int, float, std::string> v( 3.14f );
+
+        BOOST_TEST_EQ( v.index(), 2 );
+        BOOST_TEST( holds_alternative<float>(v) );
+        BOOST_TEST_EQ( get<2>(v), 3.14f );
+    }
+
+    {
+        variant<int, int, float, std::string> v( "text" );
+
+        BOOST_TEST_EQ( v.index(), 3 );
+        BOOST_TEST( holds_alternative<std::string>(v) );
+        BOOST_TEST_EQ( get<3>(v), std::string("text") );
+    }
+
+    return boost::report_errors();
+}
diff --git a/test/variant_value_construct_cx.cpp b/test/variant_value_construct_cx.cpp
new file mode 100644
index 0000000..5ffad25
--- /dev/null
+++ b/test/variant_value_construct_cx.cpp
@@ -0,0 +1,109 @@
+
+// Copyright 2017 Peter Dimov.
+//
+// Distributed under the Boost Software License, Version 1.0.
+//
+// See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/variant2/variant.hpp>
+
+using namespace boost::variant2;
+
+struct X
+{
+    constexpr operator int() const { return 2; }
+};
+
+#define STATIC_ASSERT(...) static_assert(__VA_ARGS__, #__VA_ARGS__)
+
+int main()
+{
+    {
+        constexpr variant<int> v( 1 );
+
+        STATIC_ASSERT( v.index() == 0 );
+        STATIC_ASSERT( get<0>(v) == 1 );
+    }
+
+    {
+        constexpr variant<int> v( 'a' );
+
+        STATIC_ASSERT( v.index() == 0 );
+        STATIC_ASSERT( get<0>(v) == 'a' );
+    }
+
+    {
+        constexpr variant<int> v( X{} );
+
+        STATIC_ASSERT( v.index() == 0 );
+        STATIC_ASSERT( get<0>(v) == 2 );
+    }
+
+    {
+        constexpr variant<int const> v( 1 );
+
+        STATIC_ASSERT( v.index() == 0 );
+        STATIC_ASSERT( get<0>(v) == 1 );
+    }
+
+    {
+        constexpr variant<int const> v( 'a' );
+
+        STATIC_ASSERT( v.index() == 0 );
+        STATIC_ASSERT( get<0>(v) == 'a' );
+    }
+
+    {
+        constexpr variant<int const> v( X{} );
+
+        STATIC_ASSERT( v.index() == 0 );
+        STATIC_ASSERT( get<0>(v) == 2 );
+    }
+
+    {
+        constexpr variant<int, float, X> v( 1 );
+
+        STATIC_ASSERT( v.index() == 0 );
+        STATIC_ASSERT( holds_alternative<int>(v) );
+        STATIC_ASSERT( get<0>(v) == 1 );
+    }
+
+    {
+        constexpr variant<int, float, X> v( 'a' );
+
+        STATIC_ASSERT( v.index() == 0 );
+        STATIC_ASSERT( holds_alternative<int>(v) );
+        STATIC_ASSERT( get<0>(v) == 'a' );
+    }
+
+    {
+        constexpr variant<int, float, X> v( 3.14f );
+
+        STATIC_ASSERT( v.index() == 1 );
+        STATIC_ASSERT( holds_alternative<float>(v) );
+        STATIC_ASSERT( get<1>(v) == 3.14f );
+    }
+
+    {
+        constexpr variant<int, float, X> v( X{} );
+
+        STATIC_ASSERT( v.index() == 2 );
+        STATIC_ASSERT( holds_alternative<X>(v) );
+    }
+
+    {
+        constexpr variant<int, int, float, X> v( 3.14f );
+
+        STATIC_ASSERT( v.index() == 2 );
+        STATIC_ASSERT( holds_alternative<float>(v) );
+        STATIC_ASSERT( get<2>(v) == 3.14f );
+    }
+
+    {
+        constexpr variant<int, int, float, X> v( X{} );
+
+        STATIC_ASSERT( v.index() == 3 );
+        STATIC_ASSERT( holds_alternative<X>(v) );
+    }
+}
diff --git a/test/variant_visit.cpp b/test/variant_visit.cpp
new file mode 100644
index 0000000..5058e3e
--- /dev/null
+++ b/test/variant_visit.cpp
@@ -0,0 +1,91 @@
+
+// Copyright 2017 Peter Dimov.
+//
+// Distributed under the Boost Software License, Version 1.0.
+//
+// See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/variant2/variant.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+#include <utility>
+#include <string>
+#include <cstdio>
+
+using namespace boost::variant2;
+
+int main()
+{
+    {
+        variant<int> v( 1 );
+
+        BOOST_TEST_EQ( (visit( []( auto x ){ return x; }, v )), 1 );
+
+        visit( []( auto x ){ BOOST_TEST_EQ( x, 1 ); }, v );
+        visit( []( auto x ){ BOOST_TEST_EQ( x, 1 ); }, std::move(v) );
+    }
+
+    {
+        variant<int> const v( 2 );
+
+        BOOST_TEST_EQ( (visit( []( auto x ){ return x; }, v )), 2 );
+
+        visit( []( auto x ){ BOOST_TEST_EQ( x, 2 ); }, v );
+        visit( []( auto x ){ BOOST_TEST_EQ( x, 2 ); }, std::move(v) );
+    }
+
+    {
+        variant<int const> v( 3 );
+
+        BOOST_TEST_EQ( (visit( []( auto x ){ return x; }, v )), 3 );
+
+        visit( []( auto x ){ BOOST_TEST_EQ( x, 3 ); }, v );
+        visit( []( auto x ){ BOOST_TEST_EQ( x, 3 ); }, std::move(v) );
+    }
+
+    {
+        variant<int const> const v( 4 );
+
+        BOOST_TEST_EQ( (visit( []( auto x ){ return x; }, v )), 4 );
+
+        visit( []( auto x ){ BOOST_TEST_EQ( x, 4 ); }, v );
+        visit( []( auto x ){ BOOST_TEST_EQ( x, 4 ); }, std::move(v) );
+    }
+
+    {
+        variant<int, float> v1( 1 );
+        variant<int, float> const v2( 3.14f );
+
+        BOOST_TEST_EQ( (visit( []( auto x1, auto x2 ){ return (int)(x1 * 1000) + (int)(x2 * 100); }, v1, v2 )), 1314 );
+
+        visit( []( auto x1, auto x2 ){ BOOST_TEST_EQ( x1, 1 ); BOOST_TEST_EQ( x2, 3.14f ); }, v1, v2 );
+        visit( []( auto x1, auto x2 ){ BOOST_TEST_EQ( x1, 1 ); BOOST_TEST_EQ( x2, 3.14f ); }, std::move(v1), std::move(v2) );
+    }
+
+    {
+        variant<int, float, double> v1( 1 );
+        variant<int, float, double> const v2( 3.14f );
+        variant<int, float, double> v3( 6.28 );
+
+        BOOST_TEST_EQ( (visit( []( auto x1, auto x2, auto x3 ){ return (int)(x1 * 100) * 1000000 + (int)(x2 * 100) * 1000 + (int)(x3 * 100); }, v1, v2, v3 )), 100314628 );
+
+        visit( []( auto x1, auto x2, auto x3 ){ BOOST_TEST_EQ( x1, 1 ); BOOST_TEST_EQ( x2, 3.14f ); BOOST_TEST_EQ( x3, 6.28 ); }, v1, v2, v3 );
+        visit( []( auto x1, auto x2, auto x3 ){ BOOST_TEST_EQ( x1, 1 ); BOOST_TEST_EQ( x2, 3.14f ); BOOST_TEST_EQ( x3, 6.28 ); }, std::move(v1), std::move(v2), std::move(v3) );
+    }
+
+    {
+        variant<int, float, double, char> v1( 1 );
+        variant<int, float, double, char> const v2( 3.14f );
+        variant<int, float, double, char> v3( 6.28 );
+        variant<int, float, double, char> const v4( 'A' );
+
+        BOOST_TEST_EQ( (visit( []( auto x1, auto x2, auto x3, auto x4 ){ return (long long)(x1 * 100) * 100000000 + (long long)(x2 * 100) * 100000 + (long long)(x3 * 10000) + (int)x4; }, v1, v2, v3, v4 )), 10031462800 + 'A' );
+
+        visit( []( auto x1, auto x2, auto x3, auto x4 ){ BOOST_TEST_EQ( x1, 1 ); BOOST_TEST_EQ( x2, 3.14f ); BOOST_TEST_EQ( x3, 6.28 ); BOOST_TEST_EQ( x4, 'A' ); }, v1, v2, v3, v4 );
+		visit( []( auto x1, auto x2, auto x3, auto x4 ){ BOOST_TEST_EQ( x1, 1 ); BOOST_TEST_EQ( x2, 3.14f ); BOOST_TEST_EQ( x3, 6.28 ); BOOST_TEST_EQ( x4, 'A' ); }, std::move(v1), std::move(v2), std::move(v3), std::move(v4) );
+    }
+
+    return boost::report_errors();
+}