Repository: Kitware/kwiver (language: python)

Issue:
Replace kwiver::vital::visit with std::visit when applicable (C++17)



Discussion / hints:

Fix patch:
diff --git a/arrows/core/metadata_map_io_csv.cxx b/arrows/core/metadata_map_io_csv.cxx
index 90906c266f..d40d760b22 100644
--- a/arrows/core/metadata_map_io_csv.cxx
+++ b/arrows/core/metadata_map_io_csv.cxx
@@ -228,7 +228,7 @@ ::operator()< kv::geo_polygon >( kv::geo_polygon const& value ) const
 kv::metadata_value
 get_subvalue( kv::metadata_value const& value, size_t index )
 {
-  return kv::visit( subvalue_visitor{ index }, value );
+  return std::visit( subvalue_visitor{ index }, value );
 }
 
 // ----------------------------------------------------------------------------
@@ -288,7 +288,7 @@ ::write_csv_item( kv::vital_metadata_tag tag,
   if( tag == kv::VITAL_META_VIDEO_MICROSECONDS )
   {
     // Print as hh:mm:ss.ssssss
-    auto const microseconds = kv::get< uint64_t >( value );
+    auto const microseconds = std::get< uint64_t >( value );
     auto const seconds = ( microseconds / 1000000 );
     auto const minutes = ( seconds / 60 );
     auto const hours = ( minutes / 60 );
@@ -302,7 +302,7 @@ ::write_csv_item( kv::vital_metadata_tag tag,
   }
   else
   {
-    kv::visit( write_visitor{ fout }, value );
+    std::visit( write_visitor{ fout }, value );
   }
 }
 
diff --git a/arrows/klv/klv_0806_user_defined_set.h b/arrows/klv/klv_0806_user_defined_set.h
index 67cfdf15a4..cfc28f20ae 100644
--- a/arrows/klv/klv_0806_user_defined_set.h
+++ b/arrows/klv/klv_0806_user_defined_set.h
@@ -11,9 +11,8 @@
 #include "klv_set.h"
 #include "klv_util.h"
 
-#include <vital/util/variant/variant.hpp>
-
 #include <ostream>
+#include <variant>
 
 namespace kwiver {
 
diff --git a/arrows/klv/klv_length_constraints.cxx b/arrows/klv/klv_length_constraints.cxx
index ebbb1175a0..8f8c0cf717 100644
--- a/arrows/klv/klv_length_constraints.cxx
+++ b/arrows/klv/klv_length_constraints.cxx
@@ -102,7 +102,7 @@ ::do_allow( size_t length ) const
   struct visitor
   {
     bool
-    operator()( vital::monostate ) const
+    operator()( std::monostate ) const
     {
       return true;
     }
@@ -128,7 +128,7 @@ ::do_allow( size_t length ) const
     size_t length;
   };
 
-  return vital::visit( visitor{ length }, m_impl );
+  return std::visit( visitor{ length }, m_impl );
 }
 
 // ----------------------------------------------------------------------------
@@ -136,7 +136,7 @@ bool
 klv_length_constraints
 ::is_free() const
 {
-  return vital::holds_alternative< vital::monostate >( m_impl );
+  return std::holds_alternative< std::monostate >( m_impl );
 }
 
 // ----------------------------------------------------------------------------
@@ -144,7 +144,7 @@ vital::optional< size_t >
 klv_length_constraints
 ::fixed() const
 {
-  auto const result = vital::get_if< size_t >( &m_impl );
+  auto const result = std::get_if< size_t >( &m_impl );
   if( result )
   {
     return *result;
@@ -160,7 +160,7 @@ size_t
 klv_length_constraints
 ::fixed_or( size_t backup ) const
 {
-  auto const result = vital::get_if< size_t >( &m_impl );
+  auto const result = std::get_if< size_t >( &m_impl );
   if( result )
   {
     return *result;
@@ -176,7 +176,7 @@ vital::optional< vital::interval< size_t > >
 klv_length_constraints
 ::interval() const
 {
-  auto const result = vital::get_if< vital::interval< size_t > >( &m_impl );
+  auto const result = std::get_if< vital::interval< size_t > >( &m_impl );
   if( result )
   {
     return *result;
@@ -192,7 +192,7 @@ vital::optional< std::set< size_t > >
 klv_length_constraints
 ::set() const
 {
-  auto const result = vital::get_if< std::set< size_t > >( &m_impl );
+  auto const result = std::get_if< std::set< size_t > >( &m_impl );
   if( result )
   {
     return *result;
@@ -216,7 +216,7 @@ ::suggested() const
   struct visitor
   {
     size_t
-    operator()( vital::monostate ) const
+    operator()( std::monostate ) const
     {
       return 1;
     }
@@ -240,7 +240,7 @@ ::suggested() const
     }
   };
 
-  return vital::visit( visitor{}, m_impl );
+  return std::visit( visitor{}, m_impl );
 }
 
 // ----------------------------------------------------------------------------
@@ -264,7 +264,7 @@ ::description() const
   struct visitor
   {
     void
-    operator()( vital::monostate ) const
+    operator()( std::monostate ) const
     {
       os << "unconstrained length";
     }
@@ -300,7 +300,7 @@ ::description() const
   };
 
   std::stringstream ss;
-  vital::visit( visitor{ ss }, m_impl );
+  std::visit( visitor{ ss }, m_impl );
   return ss.str();
 }
 
diff --git a/arrows/klv/klv_length_constraints.h b/arrows/klv/klv_length_constraints.h
index 1740f6d474..231c87026c 100644
--- a/arrows/klv/klv_length_constraints.h
+++ b/arrows/klv/klv_length_constraints.h
@@ -12,9 +12,9 @@
 
 #include <vital/optional.h>
 #include <vital/util/interval.h>
-#include <vital/util/variant/variant.hpp>
 
 #include <set>
+#include <variant>
 
 namespace kwiver {
 
@@ -79,8 +79,8 @@ class KWIVER_ALGO_KLV_EXPORT klv_length_constraints
   description() const;
 
 private:
-  vital::variant<
-    vital::monostate, size_t, vital::interval< size_t >, std::set< size_t >
+  std::variant<
+    std::monostate, size_t, vital::interval< size_t >, std::set< size_t >
     > m_impl;
   vital::optional< size_t > m_suggested;
 };
diff --git a/arrows/klv/klv_update_intervals.h b/arrows/klv/klv_update_intervals.h
index 31571cf82a..d7df76d17e 100644
--- a/arrows/klv/klv_update_intervals.h
+++ b/arrows/klv/klv_update_intervals.h
@@ -10,7 +10,7 @@
 
 #include <arrows/klv/klv_timeline.h>
 
-#include <vital/util/variant/variant.hpp>
+#include <variant>
 
 namespace kwiver {
 
diff --git a/arrows/serialize/json/klv/load_save_klv.cxx b/arrows/serialize/json/klv/load_save_klv.cxx
index b98804b8a2..ce1c5f6448 100644
--- a/arrows/serialize/json/klv/load_save_klv.cxx
+++ b/arrows/serialize/json/klv/load_save_klv.cxx
@@ -15,6 +15,7 @@
 #include <vital/util/visit.h>
 
 #include <stdexcept>
+#include <variant>
 
 using namespace kwiver::arrows::klv;
 namespace kv = kwiver::vital;
@@ -29,7 +30,7 @@ namespace {
 // ----------------------------------------------------------------------------
 // List of types supported by this JSON exporter/importer.
 using klv_type_list =
-  kv::variant<
+  std::variant<
     double,
     int64_t,
     klv_0102_country_coding_method,
diff --git a/arrows/serialize/json/load_save_metadata.cxx b/arrows/serialize/json/load_save_metadata.cxx
index 1373aad8dc..8a583d0ddb 100644
--- a/arrows/serialize/json/load_save_metadata.cxx
+++ b/arrows/serialize/json/load_save_metadata.cxx
@@ -62,7 +62,7 @@ struct meta_item
 
     archive( ::cereal::make_nvp( "tag", m_tag ) );
 
-    kv::visit( save_visitor< Archive >{ archive }, m_value );
+    std::visit( save_visitor< Archive >{ archive }, m_value );
 
     // These two items are included to increase readability of the
     // serialized form and are not used when deserializing.
diff --git a/arrows/serialize/protobuf/convert_protobuf.cxx b/arrows/serialize/protobuf/convert_protobuf.cxx
index 602812d2b9..9038d4c8b1 100644
--- a/arrows/serialize/protobuf/convert_protobuf.cxx
+++ b/arrows/serialize/protobuf/convert_protobuf.cxx
@@ -650,7 +650,7 @@ void convert_protobuf( const ::kwiver::vital::metadata& metadata,
 
     proto_item->set_metadata_tag( tag );
 
-    ::kwiver::vital::visit( convert_visitor{ *proto_item }, metap->data() );
+    ::std::visit( convert_visitor{ *proto_item }, metap->data() );
   } //end for
 }
 
diff --git a/python/kwiver/sprokit/pipeline_util/load.cxx b/python/kwiver/sprokit/pipeline_util/load.cxx
index 58f98ff3b1..3425006612 100644
--- a/python/kwiver/sprokit/pipeline_util/load.cxx
+++ b/python/kwiver/sprokit/pipeline_util/load.cxx
@@ -218,7 +218,7 @@ class pipe_block_visitor
 object
 pipe_block_config(::sprokit::pipe_block const& block)
 {
-  return kwiver::vital::visit( pipe_block_visitor(pipe_block_visitor::BLOCK_CONFIG), block);
+  return std::visit( pipe_block_visitor(pipe_block_visitor::BLOCK_CONFIG), block);
 }
 
 // ----------------------------------------------------------------------------
@@ -232,7 +232,7 @@ pipe_block_config_set(::sprokit::pipe_block& block, ::sprokit::config_pipe_block
 object
 pipe_block_process(::sprokit::pipe_block const& block)
 {
-  return kwiver::vital::visit(pipe_block_visitor(pipe_block_visitor::BLOCK_PROCESS), block);
+  return std::visit(pipe_block_visitor(pipe_block_visitor::BLOCK_PROCESS), block);
 }
 
 // ----------------------------------------------------------------------------
@@ -246,7 +246,7 @@ pipe_block_process_set(::sprokit::pipe_block& block, ::sprokit::process_pipe_blo
 object
 pipe_block_connect(::sprokit::pipe_block const& block)
 {
-  return kwiver::vital::visit(pipe_block_visitor(pipe_block_visitor::BLOCK_CONNECT), block);
+  return std::visit(pipe_block_visitor(pipe_block_visitor::BLOCK_CONNECT), block);
 }
 
 // ----------------------------------------------------------------------------
@@ -281,7 +281,7 @@ class cluster_subblock_visitor
 object
 cluster_subblock_config(::sprokit::cluster_subblock_t const& subblock)
 {
-  return kwiver::vital::visit(cluster_subblock_visitor(cluster_subblock_visitor::BLOCK_CONFIG), subblock);
+  return std::visit(cluster_subblock_visitor(cluster_subblock_visitor::BLOCK_CONFIG), subblock);
 }
 
 // ----------------------------------------------------------------------------
@@ -295,7 +295,7 @@ cluster_subblock_config_set(::sprokit::cluster_subblock_t& subblock, ::sprokit::
 object
 cluster_subblock_input(::sprokit::cluster_subblock_t const& subblock)
 {
-  return kwiver::vital::visit(cluster_subblock_visitor(cluster_subblock_visitor::BLOCK_INPUT), subblock);
+  return std::visit(cluster_subblock_visitor(cluster_subblock_visitor::BLOCK_INPUT), subblock);
 }
 
 // ----------------------------------------------------------------------------
@@ -309,7 +309,7 @@ cluster_subblock_input_set(::sprokit::cluster_subblock_t& subblock, ::sprokit::c
 object
 cluster_subblock_output(::sprokit::cluster_subblock_t const& subblock)
 {
-  return kwiver::vital::visit(cluster_subblock_visitor(cluster_subblock_visitor::BLOCK_OUTPUT), subblock);
+  return std::visit(cluster_subblock_visitor(cluster_subblock_visitor::BLOCK_OUTPUT), subblock);
 }
 
 // ----------------------------------------------------------------------------
@@ -323,7 +323,7 @@ cluster_subblock_output_set(::sprokit::cluster_subblock_t& subblock, ::sprokit::
 object
 cluster_block_config(::sprokit::cluster_block const& block)
 {
-  return kwiver::vital::visit(pipe_block_visitor(pipe_block_visitor::BLOCK_CONFIG), block);
+  return std::visit(pipe_block_visitor(pipe_block_visitor::BLOCK_CONFIG), block);
 }
 
 // ----------------------------------------------------------------------------
@@ -337,7 +337,7 @@ cluster_block_config_set(::sprokit::cluster_block& block, ::sprokit::config_pipe
 object
 cluster_block_process(::sprokit::cluster_block const& block)
 {
-  return kwiver::vital::visit(pipe_block_visitor(pipe_block_visitor::BLOCK_PROCESS), block);
+  return std::visit(pipe_block_visitor(pipe_block_visitor::BLOCK_PROCESS), block);
 }
 
 // ----------------------------------------------------------------------------
@@ -351,7 +351,7 @@ cluster_block_process_set(::sprokit::cluster_block& block, ::sprokit::process_pi
 object
 cluster_block_connect(::sprokit::cluster_block const& block)
 {
-  return kwiver::vital::visit(pipe_block_visitor(pipe_block_visitor::BLOCK_CONNECT), block);
+  return std::visit(pipe_block_visitor(pipe_block_visitor::BLOCK_CONNECT), block);
 }
 
 // ----------------------------------------------------------------------------
@@ -365,7 +365,7 @@ cluster_block_connect_set(::sprokit::cluster_block& block, ::sprokit::connect_pi
 object
 cluster_block_cluster(::sprokit::cluster_block const& block)
 {
-  return kwiver::vital::visit(pipe_block_visitor(pipe_block_visitor::BLOCK_CLUSTER), block);
+  return std::visit(pipe_block_visitor(pipe_block_visitor::BLOCK_CLUSTER), block);
 }
 
 // ----------------------------------------------------------------------------
diff --git a/python/kwiver/vital/types/metadata.cxx b/python/kwiver/vital/types/metadata.cxx
index d0b66ff75c..a56ac4b207 100644
--- a/python/kwiver/vital/types/metadata.cxx
+++ b/python/kwiver/vital/types/metadata.cxx
@@ -49,7 +49,7 @@ from_py( vital_metadata_tag tag, py::object data ) {
 // ----------------------------------------------------------------------------
 py::object
 to_py( metadata_value const& data ) {
-  return kwiver::vital::visit( to_py_visitor{}, data );
+  return std::visit( to_py_visitor{}, data );
 }
 
 // ----------------------------------------------------------------------------
diff --git a/sprokit/src/sprokit/pipeline_util/bakery_base.h b/sprokit/src/sprokit/pipeline_util/bakery_base.h
index 9e7a3f62f7..4466e47dda 100644
--- a/sprokit/src/sprokit/pipeline_util/bakery_base.h
+++ b/sprokit/src/sprokit/pipeline_util/bakery_base.h
@@ -16,9 +16,9 @@
 #include <vital/util/token_expander.h>
 #include <vital/util/token_type_symtab.h>
 #include <vital/logger/logger.h>
-#include <vital/util/variant/variant.hpp>
 
 #include <map>
+#include <variant>
 
 namespace sprokit {
 
diff --git a/sprokit/src/sprokit/pipeline_util/cluster_bakery.cxx b/sprokit/src/sprokit/pipeline_util/cluster_bakery.cxx
index 91b66b0d68..7087610eb6 100644
--- a/sprokit/src/sprokit/pipeline_util/cluster_bakery.cxx
+++ b/sprokit/src/sprokit/pipeline_util/cluster_bakery.cxx
@@ -48,7 +48,7 @@ ::operator()( cluster_pipe_block const& cluster_block_ )
   // These lists end up in "cluster"
   for ( auto sb : subblocks )
   {
-    kwiver::vital::visit( splitter, sb );
+    std::visit( splitter, sb );
   }
 
   m_cluster = cluster;
diff --git a/sprokit/src/sprokit/pipeline_util/export_pipe.cxx b/sprokit/src/sprokit/pipeline_util/export_pipe.cxx
index 2c6f17d81a..315456da55 100644
--- a/sprokit/src/sprokit/pipeline_util/export_pipe.cxx
+++ b/sprokit/src/sprokit/pipeline_util/export_pipe.cxx
@@ -393,7 +393,7 @@ generate( std::ostream& str )
 
   for ( auto b : blocks )
   {
-    kwiver::vital::visit( printer, b );
+    std::visit( printer, b );
   }
 
   printer.output_process_defaults();
diff --git a/sprokit/src/sprokit/pipeline_util/pipe_bakery.cxx b/sprokit/src/sprokit/pipeline_util/pipe_bakery.cxx
index 340b6718a8..e71deeb8ce 100644
--- a/sprokit/src/sprokit/pipeline_util/pipe_bakery.cxx
+++ b/sprokit/src/sprokit/pipeline_util/pipe_bakery.cxx
@@ -57,7 +57,7 @@ bake_pipe_blocks( pipe_blocks const& blocks )
   // apply main visitor to collect
   for ( auto b : blocks )
   {
-    kwiver::vital::visit( bakery, b );
+    std::visit( bakery, b );
   }
 
   bakery_base::config_decls_t& configs = bakery.m_configs;
@@ -112,7 +112,7 @@ bake_cluster_blocks( cluster_blocks const& blocks )
 
   for ( auto b : blocks )
   {
-    kwiver::vital::visit( *bakery, b );
+    std::visit( *bakery, b );
   }
 
   if ( bakery->m_processes.empty() )
@@ -155,7 +155,7 @@ extract_configuration( pipe_blocks const& blocks )
 
   for (auto b : blocks )
   {
-    kwiver::vital::visit( bakery, b );
+    std::visit( bakery, b );
   }
 
   bakery_base::config_decls_t& configs = bakery.m_configs;
diff --git a/sprokit/src/sprokit/pipeline_util/pipe_declaration_types.h b/sprokit/src/sprokit/pipeline_util/pipe_declaration_types.h
index 4c7a2faea0..cdbd517180 100644
--- a/sprokit/src/sprokit/pipeline_util/pipe_declaration_types.h
+++ b/sprokit/src/sprokit/pipeline_util/pipe_declaration_types.h
@@ -7,11 +7,11 @@
 
 #include <vital/config/config_block.h>
 #include <vital/util/source_location.h>
-#include <vital/util/variant/variant.hpp>
 
 #include <sprokit/pipeline/process.h>
 
 #include <string>
+#include <variant>
 #include <vector>
 
 /**
@@ -138,7 +138,7 @@ struct connect_pipe_block
 };
 
 /// A discriminating union over all available pipeline block types.
-typedef kwiver::vital::variant
+typedef std::variant
   < config_pipe_block
   , process_pipe_block
   , connect_pipe_block
@@ -208,7 +208,7 @@ struct cluster_output_t
 };
 
 /// A variant over the possible blocks that may be contained within a cluster.
-typedef kwiver::vital::variant<cluster_config_t, cluster_input_t, cluster_output_t> cluster_subblock_t;
+typedef std::variant<cluster_config_t, cluster_input_t, cluster_output_t> cluster_subblock_t;
 
 /// A type for a collection of cluster subblocks.
 typedef std::vector<cluster_subblock_t> cluster_subblocks_t;
@@ -232,7 +232,7 @@ struct cluster_pipe_block
 };
 
 /// A discriminating union over all available cluster block types.
-typedef kwiver::vital::variant
+typedef std::variant
   < config_pipe_block
   , process_pipe_block
   , connect_pipe_block
diff --git a/sprokit/src/sprokit/pipeline_util/pipe_display.cxx b/sprokit/src/sprokit/pipeline_util/pipe_display.cxx
index 61acef1ada..e89fde5d75 100644
--- a/sprokit/src/sprokit/pipeline_util/pipe_display.cxx
+++ b/sprokit/src/sprokit/pipeline_util/pipe_display.cxx
@@ -207,7 +207,7 @@ ::display_pipe_blocks( const sprokit::pipe_blocks blocks )
 
   for ( auto b : blocks )
   {
-    kwiver::vital::visit( printer, b );
+    std::visit( printer, b );
   }
 }
 
diff --git a/vital/types/metadata.cxx b/vital/types/metadata.cxx
index aa81d164cc..4091fd96aa 100644
--- a/vital/types/metadata.cxx
+++ b/vital/types/metadata.cxx
@@ -143,7 +143,7 @@ double
 metadata_item
 ::as_double() const
 {
-  return kwiver::vital::get< double >( this->m_data );
+  return std::get< double >( this->m_data );
 }
 
 // ----------------------------------------------------------------------------
@@ -159,7 +159,7 @@ uint64_t
 metadata_item
 ::as_uint64() const
 {
-  return kwiver::vital::get< uint64_t >( this->m_data );
+  return std::get< uint64_t >( this->m_data );
 }
 
 // ----------------------------------------------------------------------------
@@ -177,7 +177,7 @@ ::as_string() const
 {
   if( this->has_string() )
   {
-    return kwiver::vital::get< std::string >( m_data );
+    return std::get< std::string >( m_data );
   }
 
   std::stringstream ss;
diff --git a/vital/types/metadata.h b/vital/types/metadata.h
index fd42a0d56d..0cf4b97a78 100644
--- a/vital/types/metadata.h
+++ b/vital/types/metadata.h
@@ -10,7 +10,6 @@
 
 #include <vital/any.h>
 #include <vital/exceptions/metadata.h>
-#include <vital/util/variant/variant.hpp>
 #include <vital/types/geo_point.h>
 #include <vital/types/geo_polygon.h>
 #include <vital/types/metadata_tags.h>
@@ -28,6 +27,7 @@
 #include <type_traits>
 #include <typeindex>
 #include <typeinfo>
+#include <variant>
 #include <vector>
 
 namespace kwiver {
@@ -35,7 +35,8 @@ namespace vital {
 
 // ----------------------------------------------------------------------------
 using metadata_value =
-  variant< bool, int, uint64_t, double, std::string, geo_point, geo_polygon >;
+  std::variant<
+    bool, int, uint64_t, double, std::string, geo_point, geo_polygon >;
 
 // ----------------------------------------------------------------------------
 /// Call \p visitor with template type parameter corresponding to \p type.
@@ -147,7 +148,7 @@ class VITAL_EXPORT metadata_item
 
   template< class T >
   T const& get() const {
-    return kwiver::vital::get< T >( m_data );
+    return std::get< T >( m_data );
   }
 
   /// Get the value of the metadata item as a \c double.
diff --git a/vital/util/CMakeLists.txt b/vital/util/CMakeLists.txt
index 15cf753aac..59175a65ce 100644
--- a/vital/util/CMakeLists.txt
+++ b/vital/util/CMakeLists.txt
@@ -35,10 +35,6 @@ set( public_headers
   token_type_sysenv.h
   tokenize.h
   transform_image.h
-  variant/config.hpp
-  variant/in_place.hpp
-  variant/lib.hpp
-  variant/variant.hpp
   visit.h
   wrap_text_block.h
   file_md5.h
diff --git a/vital/util/variant/config.hpp b/vital/util/variant/config.hpp
deleted file mode 100644
index 139de7da3b..0000000000
--- a/vital/util/variant/config.hpp
+++ /dev/null
@@ -1,72 +0,0 @@
-// MPark.Variant
-//
-// Copyright Michael Park, 2015-2017
-//
-// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
-
-#ifndef MPARK_CONFIG_HPP
-#define MPARK_CONFIG_HPP
-
-// MSVC 2015 Update 3.
-#if __cplusplus < 201103L && (!defined(_MSC_VER) || _MSC_FULL_VER < 190024210)
-#error "MPark.Variant requires C++11 support."
-#endif
-
-#ifndef __has_builtin
-#define __has_builtin(x) 0
-#endif
-
-#ifndef __has_include
-#define __has_include(x) 0
-#endif
-
-#ifndef __has_feature
-#define __has_feature(x) 0
-#endif
-
-#if __has_builtin(__builtin_addressof) || \
-    (defined(__GNUC__) && __GNUC__ >= 7) || defined(_MSC_VER)
-#define MPARK_BUILTIN_ADDRESSOF
-#endif
-
-#if __has_builtin(__builtin_unreachable)
-#define MPARK_BUILTIN_UNREACHABLE
-#endif
-
-#if __has_builtin(__type_pack_element)
-#define MPARK_TYPE_PACK_ELEMENT
-#endif
-
-#if defined(__cpp_constexpr) && __cpp_constexpr >= 201304 && \
-    !(defined(_MSC_VER) && _MSC_VER <= 1915)
-#define MPARK_CPP14_CONSTEXPR
-#endif
-
-#define MPARK_EXCEPTIONS
-
-#if defined(__cpp_generic_lambdas) || defined(_MSC_VER)
-#define MPARK_GENERIC_LAMBDAS
-#endif
-
-#if defined(__cpp_lib_integer_sequence)
-#define MPARK_INTEGER_SEQUENCE
-#endif
-
-#if defined(__cpp_return_type_deduction) || defined(_MSC_VER)
-#define MPARK_RETURN_TYPE_DEDUCTION
-#endif
-
-#if defined(__cpp_lib_transparent_operators) || defined(_MSC_VER)
-#define MPARK_TRANSPARENT_OPERATORS
-#endif
-
-#if defined(__cpp_variable_templates) || defined(_MSC_VER)
-#define MPARK_VARIABLE_TEMPLATES
-#endif
-
-#if !defined(__GLIBCXX__) || __has_include(<codecvt>)  // >= libstdc++-5
-#define MPARK_TRIVIALITY_TYPE_TRAITS
-#endif
-
-#endif  // MPARK_CONFIG_HPP
diff --git a/vital/util/variant/in_place.hpp b/vital/util/variant/in_place.hpp
deleted file mode 100644
index 3dadaca823..0000000000
--- a/vital/util/variant/in_place.hpp
+++ /dev/null
@@ -1,34 +0,0 @@
-// MPark.Variant
-//
-// Copyright Michael Park, 2015-2017
-//
-// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
-
-#ifndef VITAL_INTERNAL_IN_PLACE_HPP
-#define VITAL_INTERNAL_IN_PLACE_HPP
-
-#include <cstddef>
-
-namespace kwiver {
-namespace vital {
-
-  struct in_place_t { explicit in_place_t() = default; };
-
-  template <std::size_t I>
-  struct in_place_index_t { explicit in_place_index_t() = default; };
-
-  template <typename T>
-  struct in_place_type_t { explicit in_place_type_t() = default; };
-
-#if 0 // c++14 feature
-  constexpr in_place_t in_place{};
-
-  template <std::size_t I> constexpr in_place_index_t<I> in_place_index{};
-
-  template <typename T> constexpr in_place_type_t<T> in_place_type{};
-#endif
-
-} }  // namespace
-
-#endif  // VITAL_INTERNAL_IN_PLACE_HPP
diff --git a/vital/util/variant/lib.hpp b/vital/util/variant/lib.hpp
deleted file mode 100644
index 074a1305e3..0000000000
--- a/vital/util/variant/lib.hpp
+++ /dev/null
@@ -1,450 +0,0 @@
-// MPark.Variant
-//
-// Copyright Michael Park, 2015-2017
-//
-// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
-
-#ifndef MPARK_LIB_HPP
-#define MPARK_LIB_HPP
-
-#include <memory>
-#include <functional>
-#include <type_traits>
-#include <utility>
-
-#include "config.hpp"
-
-#define RETURN(...) -> decltype(__VA_ARGS__) { return __VA_ARGS__; }
-
-//namespace mpark {
-namespace kwiver {
-namespace vital{
-
-  namespace lib {
-    template <typename T>
-    struct identity { using type = T; };
-
-    inline namespace cpp14 {
-      template <typename T, std::size_t N>
-      struct array {
-        constexpr const T &operator[](std::size_t index) const {
-          return data[index];
-        }
-
-        T data[N == 0 ? 1 : N];
-      };
-
-      template <typename T>
-      using add_pointer_t = typename std::add_pointer<T>::type;
-
-      template <typename... Ts>
-      using common_type_t = typename std::common_type<Ts...>::type;
-
-      template <typename T>
-      using decay_t = typename std::decay<T>::type;
-
-      template <bool B, typename T = void>
-      using enable_if_t = typename std::enable_if<B, T>::type;
-
-      template <typename T>
-      using remove_const_t = typename std::remove_const<T>::type;
-
-      template <typename T>
-      using remove_reference_t = typename std::remove_reference<T>::type;
-
-      template <typename T>
-      inline constexpr T &&forward(remove_reference_t<T> &t) noexcept {
-        return static_cast<T &&>(t);
-      }
-
-      template <typename T>
-      inline constexpr T &&forward(remove_reference_t<T> &&t) noexcept {
-        static_assert(!std::is_lvalue_reference<T>::value,
-                      "can not forward an rvalue as an lvalue");
-        return static_cast<T &&>(t);
-      }
-
-      template <typename T>
-      inline constexpr remove_reference_t<T> &&move(T &&t) noexcept {
-        return static_cast<remove_reference_t<T> &&>(t);
-      }
-
-#ifdef MPARK_INTEGER_SEQUENCE
-      using std::integer_sequence;
-      using std::index_sequence;
-      using std::make_index_sequence;
-      using std::index_sequence_for;
-#else
-      template <typename T, T... Is>
-      struct integer_sequence {
-        using value_type = T;
-        static constexpr std::size_t size() noexcept { return sizeof...(Is); }
-      };
-
-      template <std::size_t... Is>
-      using index_sequence = integer_sequence<std::size_t, Is...>;
-
-      template <typename Lhs, typename Rhs>
-      struct make_index_sequence_concat;
-
-      template <std::size_t... Lhs, std::size_t... Rhs>
-      struct make_index_sequence_concat<index_sequence<Lhs...>,
-                                        index_sequence<Rhs...>>
-          : identity<index_sequence<Lhs..., (sizeof...(Lhs) + Rhs)...>> {};
-
-      template <std::size_t N>
-      struct make_index_sequence_impl;
-
-      template <std::size_t N>
-      using make_index_sequence = typename make_index_sequence_impl<N>::type;
-
-      template <std::size_t N>
-      struct make_index_sequence_impl
-          : make_index_sequence_concat<make_index_sequence<N / 2>,
-                                       make_index_sequence<N - (N / 2)>> {};
-
-      template <>
-      struct make_index_sequence_impl<0> : identity<index_sequence<>> {};
-
-      template <>
-      struct make_index_sequence_impl<1> : identity<index_sequence<0>> {};
-
-      template <typename... Ts>
-      using index_sequence_for = make_index_sequence<sizeof...(Ts)>;
-#endif
-
-      // <functional>
-#ifdef MPARK_TRANSPARENT_OPERATORS
-      using equal_to = std::equal_to<>;
-#else
-      struct equal_to {
-        template <typename Lhs, typename Rhs>
-        inline constexpr auto operator()(Lhs &&lhs, Rhs &&rhs) const
-          RETURN(lib::forward<Lhs>(lhs) == lib::forward<Rhs>(rhs))
-      };
-#endif
-
-#ifdef MPARK_TRANSPARENT_OPERATORS
-      using not_equal_to = std::not_equal_to<>;
-#else
-      struct not_equal_to {
-        template <typename Lhs, typename Rhs>
-        inline constexpr auto operator()(Lhs &&lhs, Rhs &&rhs) const
-          RETURN(lib::forward<Lhs>(lhs) != lib::forward<Rhs>(rhs))
-      };
-#endif
-
-#ifdef MPARK_TRANSPARENT_OPERATORS
-      using less = std::less<>;
-#else
-      struct less {
-        template <typename Lhs, typename Rhs>
-        inline constexpr auto operator()(Lhs &&lhs, Rhs &&rhs) const
-          RETURN(lib::forward<Lhs>(lhs) < lib::forward<Rhs>(rhs))
-      };
-#endif
-
-#ifdef MPARK_TRANSPARENT_OPERATORS
-      using greater = std::greater<>;
-#else
-      struct greater {
-        template <typename Lhs, typename Rhs>
-        inline constexpr auto operator()(Lhs &&lhs, Rhs &&rhs) const
-          RETURN(lib::forward<Lhs>(lhs) > lib::forward<Rhs>(rhs))
-      };
-#endif
-
-#ifdef MPARK_TRANSPARENT_OPERATORS
-      using less_equal = std::less_equal<>;
-#else
-      struct less_equal {
-        template <typename Lhs, typename Rhs>
-        inline constexpr auto operator()(Lhs &&lhs, Rhs &&rhs) const
-          RETURN(lib::forward<Lhs>(lhs) <= lib::forward<Rhs>(rhs))
-      };
-#endif
-
-#ifdef MPARK_TRANSPARENT_OPERATORS
-      using greater_equal = std::greater_equal<>;
-#else
-      struct greater_equal {
-        template <typename Lhs, typename Rhs>
-        inline constexpr auto operator()(Lhs &&lhs, Rhs &&rhs) const
-          RETURN(lib::forward<Lhs>(lhs) >= lib::forward<Rhs>(rhs))
-      };
-#endif
-    }  // namespace cpp14
-
-    inline namespace cpp17 {
-
-      // <type_traits>
-      template <bool B>
-      using bool_constant = std::integral_constant<bool, B>;
-
-      template <typename...>
-      struct voider : identity<void> {};
-
-      template <typename... Ts>
-      using void_t = typename voider<Ts...>::type;
-
-      namespace detail {
-        namespace swappable {
-
-          using std::swap;
-
-          template <typename T>
-          struct is_swappable {
-            private:
-            template <typename U,
-                      typename = decltype(swap(std::declval<U &>(),
-                                               std::declval<U &>()))>
-            inline static std::true_type test(int);
-
-            template <typename U>
-            inline static std::false_type test(...);
-
-            public:
-            static constexpr bool value = decltype(test<T>(0))::value;
-          };
-
-          template <typename T, bool = is_swappable<T>::value>
-          struct is_nothrow_swappable {
-#if defined(__GNUC__) && !defined(__clang__)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wnoexcept"
-#endif
-            static constexpr bool value =
-                noexcept(swap(std::declval<T &>(), std::declval<T &>()));
-#if defined(__GNUC__) && !defined(__clang__)
-#pragma GCC diagnostic pop
-#endif
-          };
-
-          template <typename T>
-          struct is_nothrow_swappable<T, false> : std::false_type {};
-
-        }  // namespace swappable
-      }  // namespace detail
-
-      using detail::swappable::is_swappable;
-      using detail::swappable::is_nothrow_swappable;
-
-      // <functional>
-#ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable : 4100)
-#endif
-      template <typename F, typename... As>
-      inline constexpr auto invoke(F &&f, As &&... as)
-          RETURN(lib::forward<F>(f)(lib::forward<As>(as)...))
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
-
-      template <typename B, typename T, typename D>
-      inline constexpr auto invoke(T B::*pmv, D &&d)
-          RETURN(lib::forward<D>(d).*pmv)
-
-      template <typename Pmv, typename Ptr>
-      inline constexpr auto invoke(Pmv pmv, Ptr &&ptr)
-          RETURN((*lib::forward<Ptr>(ptr)).*pmv)
-
-      template <typename B, typename T, typename D, typename... As>
-      inline constexpr auto invoke(T B::*pmf, D &&d, As &&... as)
-          RETURN((lib::forward<D>(d).*pmf)(lib::forward<As>(as)...))
-
-      template <typename Pmf, typename Ptr, typename... As>
-      inline constexpr auto invoke(Pmf pmf, Ptr &&ptr, As &&... as)
-          RETURN(((*lib::forward<Ptr>(ptr)).*pmf)(lib::forward<As>(as)...))
-
-      namespace detail {
-
-        template <typename Void, typename, typename...>
-        struct invoke_result {};
-
-        template <typename F, typename... Args>
-        struct invoke_result<void_t<decltype(lib::invoke(
-                                 std::declval<F>(), std::declval<Args>()...))>,
-                             F,
-                             Args...>
-            : identity<decltype(
-                  lib::invoke(std::declval<F>(), std::declval<Args>()...))> {};
-
-      }  // namespace detail
-
-      template <typename F, typename... Args>
-      using invoke_result = detail::invoke_result<void, F, Args...>;
-
-      template <typename F, typename... Args>
-      using invoke_result_t = typename invoke_result<F, Args...>::type;
-
-      namespace detail {
-
-        template <typename Void, typename, typename...>
-        struct is_invocable : std::false_type {};
-
-        template <typename F, typename... Args>
-        struct is_invocable<void_t<invoke_result_t<F, Args...>>, F, Args...>
-            : std::true_type {};
-
-        template <typename Void, typename, typename, typename...>
-        struct is_invocable_r : std::false_type {};
-
-        template <typename R, typename F, typename... Args>
-        struct is_invocable_r<void_t<invoke_result_t<F, Args...>>,
-                              R,
-                              F,
-                              Args...>
-            : std::is_convertible<invoke_result_t<F, Args...>, R> {};
-
-      }  // namespace detail
-
-      template <typename F, typename... Args>
-      using is_invocable = detail::is_invocable<void, F, Args...>;
-
-      template <typename R, typename F, typename... Args>
-      using is_invocable_r = detail::is_invocable_r<void, R, F, Args...>;
-
-      // <memory>
-#ifdef MPARK_BUILTIN_ADDRESSOF
-      template <typename T>
-      inline constexpr T *addressof(T &arg) noexcept {
-        return __builtin_addressof(arg);
-      }
-#else
-      namespace detail {
-
-        namespace has_addressof_impl {
-
-          struct fail;
-
-          template <typename T>
-          inline fail operator&(T &&);
-
-          template <typename T>
-          inline static constexpr bool impl() {
-            return (std::is_class<T>::value || std::is_union<T>::value) &&
-                   !std::is_same<decltype(&std::declval<T &>()), fail>::value;
-          }
-
-        }  // namespace has_addressof_impl
-
-        template <typename T>
-        using has_addressof = bool_constant<has_addressof_impl::impl<T>()>;
-
-        template <typename T>
-        inline constexpr T *addressof(T &arg, std::true_type) noexcept {
-          return std::addressof(arg);
-        }
-
-        template <typename T>
-        inline constexpr T *addressof(T &arg, std::false_type) noexcept {
-          return &arg;
-        }
-
-      }  // namespace detail
-
-      template <typename T>
-      inline constexpr T *addressof(T &arg) noexcept {
-        return detail::addressof(arg, detail::has_addressof<T>{});
-      }
-#endif
-
-      template <typename T>
-      inline constexpr T *addressof(const T &&) = delete;
-
-    }  // namespace cpp17
-
-    template <typename T>
-    struct remove_all_extents : identity<T> {};
-
-    template <typename T, std::size_t N>
-    struct remove_all_extents<array<T, N>> : remove_all_extents<T> {};
-
-    template <typename T>
-    using remove_all_extents_t = typename remove_all_extents<T>::type;
-
-    template <std::size_t N>
-    using size_constant = std::integral_constant<std::size_t, N>;
-
-    template <std::size_t I, typename T>
-    struct indexed_type : size_constant<I>, identity<T> {};
-
-    template <bool... Bs>
-    using all = std::is_same<integer_sequence<bool, true, Bs...>,
-                             integer_sequence<bool, Bs..., true>>;
-
-#ifdef MPARK_TYPE_PACK_ELEMENT
-    template <std::size_t I, typename... Ts>
-    using type_pack_element_t = __type_pack_element<I, Ts...>;
-#else
-    template <std::size_t I, typename... Ts>
-    struct type_pack_element_impl {
-      private:
-      template <typename>
-      struct set;
-
-      template <std::size_t... Is>
-      struct set<index_sequence<Is...>> : indexed_type<Is, Ts>... {};
-
-      template <typename T>
-      inline static std::enable_if<true, T> impl(indexed_type<I, T>);
-
-      inline static std::enable_if<false> impl(...);
-
-      public:
-      using type = decltype(impl(set<index_sequence_for<Ts...>>{}));
-    };
-
-    template <std::size_t I, typename... Ts>
-    using type_pack_element = typename type_pack_element_impl<I, Ts...>::type;
-
-    template <std::size_t I, typename... Ts>
-    using type_pack_element_t = typename type_pack_element<I, Ts...>::type;
-#endif
-
-#ifdef MPARK_TRIVIALITY_TYPE_TRAITS
-    using std::is_trivially_copy_constructible;
-    using std::is_trivially_move_constructible;
-    using std::is_trivially_copy_assignable;
-    using std::is_trivially_move_assignable;
-#else
-    template <typename T>
-    struct is_trivially_copy_constructible
-        : bool_constant<
-              std::is_copy_constructible<T>::value && __has_trivial_copy(T)> {};
-
-    template <typename T>
-    struct is_trivially_move_constructible : bool_constant<__is_trivial(T)> {};
-
-    template <typename T>
-    struct is_trivially_copy_assignable
-        : bool_constant<
-              std::is_copy_assignable<T>::value && __has_trivial_assign(T)> {};
-
-    template <typename T>
-    struct is_trivially_move_assignable : bool_constant<__is_trivial(T)> {};
-#endif
-
-    template <typename T, bool>
-    struct dependent_type : T {};
-
-    template <typename Is, std::size_t J>
-    struct push_back;
-
-    template <typename Is, std::size_t J>
-    using push_back_t = typename push_back<Is, J>::type;
-
-    template <std::size_t... Is, std::size_t J>
-    struct push_back<index_sequence<Is...>, J> {
-      using type = index_sequence<Is..., J>;
-    };
-
-  }  // namespace lib
-}  // namespace vital - mpark
-}// namespace kwiver
-
-#undef RETURN
-
-#endif  // MPARK_LIB_HPP
diff --git a/vital/util/variant/variant.hpp b/vital/util/variant/variant.hpp
deleted file mode 100644
index eb1f918226..0000000000
--- a/vital/util/variant/variant.hpp
+++ /dev/null
@@ -1,1925 +0,0 @@
-// MPark.Variant
-//
-// Copyright Michael Park, 2015-2017
-//
-// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
-
-#ifndef MPARK_VARIANT_HPP
-#define MPARK_VARIANT_HPP
-
-/*
-   variant synopsis
-
-namespace std {
-
-  // 20.7.2, class template variant
-  template <class... Types>
-  class variant {
-  public:
-
-    // 20.7.2.1, constructors
-    constexpr variant() noexcept(see below);
-    variant(const variant&);
-    variant(variant&&) noexcept(see below);
-
-    template <class T> constexpr variant(T&&) noexcept(see below);
-
-    template <class T, class... Args>
-    constexpr explicit variant(in_place_type_t<T>, Args&&...);
-
-    template <class T, class U, class... Args>
-    constexpr explicit variant(
-        in_place_type_t<T>, initializer_list<U>, Args&&...);
-
-    template <size_t I, class... Args>
-    constexpr explicit variant(in_place_index_t<I>, Args&&...);
-
-    template <size_t I, class U, class... Args>
-    constexpr explicit variant(
-        in_place_index_t<I>, initializer_list<U>, Args&&...);
-
-    // 20.7.2.2, destructor
-    ~variant();
-
-    // 20.7.2.3, assignment
-    variant& operator=(const variant&);
-    variant& operator=(variant&&) noexcept(see below);
-
-    template <class T> variant& operator=(T&&) noexcept(see below);
-
-    // 20.7.2.4, modifiers
-    template <class T, class... Args>
-    T& emplace(Args&&...);
-
-    template <class T, class U, class... Args>
-    T& emplace(initializer_list<U>, Args&&...);
-
-    template <size_t I, class... Args>
-    variant_alternative<I, variant>& emplace(Args&&...);
-
-    template <size_t I, class U, class...  Args>
-    variant_alternative<I, variant>& emplace(initializer_list<U>, Args&&...);
-
-    // 20.7.2.5, value status
-    constexpr bool valueless_by_exception() const noexcept;
-    constexpr size_t index() const noexcept;
-
-    // 20.7.2.6, swap
-    void swap(variant&) noexcept(see below);
-  };
-
-  // 20.7.3, variant helper classes
-  template <class T> struct variant_size; // undefined
-
-  template <class T>
-  constexpr size_t variant_size_v = variant_size<T>::value;
-
-  template <class T> struct variant_size<const T>;
-  template <class T> struct variant_size<volatile T>;
-  template <class T> struct variant_size<const volatile T>;
-
-  template <class... Types>
-  struct variant_size<variant<Types...>>;
-
-  template <size_t I, class T> struct variant_alternative; // undefined
-
-  template <size_t I, class T>
-  using variant_alternative_t = typename variant_alternative<I, T>::type;
-
-  template <size_t I, class T> struct variant_alternative<I, const T>;
-  template <size_t I, class T> struct variant_alternative<I, volatile T>;
-  template <size_t I, class T> struct variant_alternative<I, const volatile T>;
-
-  template <size_t I, class... Types>
-  struct variant_alternative<I, variant<Types...>>;
-
-  constexpr size_t variant_npos = -1;
-
-  // 20.7.4, value access
-  template <class T, class... Types>
-  constexpr bool holds_alternative(const variant<Types...>&) noexcept;
-
-  template <size_t I, class... Types>
-  constexpr variant_alternative_t<I, variant<Types...>>&
-  get(variant<Types...>&);
-
-  template <size_t I, class... Types>
-  constexpr variant_alternative_t<I, variant<Types...>>&&
-  get(variant<Types...>&&);
-
-  template <size_t I, class... Types>
-  constexpr variant_alternative_t<I, variant<Types...>> const&
-  get(const variant<Types...>&);
-
-  template <size_t I, class... Types>
-  constexpr variant_alternative_t<I, variant<Types...>> const&&
-  get(const variant<Types...>&&);
-
-  template <class T, class...  Types>
-  constexpr T& get(variant<Types...>&);
-
-  template <class T, class... Types>
-  constexpr T&& get(variant<Types...>&&);
-
-  template <class T, class... Types>
-  constexpr const T& get(const variant<Types...>&);
-
-  template <class T, class... Types>
-  constexpr const T&& get(const variant<Types...>&&);
-
-  template <size_t I, class... Types>
-  constexpr add_pointer_t<variant_alternative_t<I, variant<Types...>>>
-  get_if(variant<Types...>*) noexcept;
-
-  template <size_t I, class... Types>
-  constexpr add_pointer_t<const variant_alternative_t<I, variant<Types...>>>
-  get_if(const variant<Types...>*) noexcept;
-
-  template <class T, class... Types>
-  constexpr add_pointer_t<T>
-  get_if(variant<Types...>*) noexcept;
-
-  template <class T, class... Types>
-  constexpr add_pointer_t<const T>
-  get_if(const variant<Types...>*) noexcept;
-
-  // 20.7.5, relational operators
-  template <class... Types>
-  constexpr bool operator==(const variant<Types...>&, const variant<Types...>&);
-
-  template <class... Types>
-  constexpr bool operator!=(const variant<Types...>&, const variant<Types...>&);
-
-  template <class... Types>
-  constexpr bool operator<(const variant<Types...>&, const variant<Types...>&);
-
-  template <class... Types>
-  constexpr bool operator>(const variant<Types...>&, const variant<Types...>&);
-
-  template <class... Types>
-  constexpr bool operator<=(const variant<Types...>&, const variant<Types...>&);
-
-  template <class... Types>
-  constexpr bool operator>=(const variant<Types...>&, const variant<Types...>&);
-
-  // 20.7.6, visitation
-  template <class Visitor, class... Variants>
-  constexpr see below visit(Visitor&&, Variants&&...);
-
-  // 20.7.7, class monostate
-  struct monostate;
-
-  // 20.7.8, monostate relational operators
-  constexpr bool operator<(monostate, monostate) noexcept;
-  constexpr bool operator>(monostate, monostate) noexcept;
-  constexpr bool operator<=(monostate, monostate) noexcept;
-  constexpr bool operator>=(monostate, monostate) noexcept;
-  constexpr bool operator==(monostate, monostate) noexcept;
-  constexpr bool operator!=(monostate, monostate) noexcept;
-
-  // 20.7.9, specialized algorithms
-  template <class... Types>
-  void swap(variant<Types...>&, variant<Types...>&) noexcept(see below);
-
-  // 20.7.10, class bad_variant_access
-  class bad_variant_access;
-
-  // 20.7.11, hash support
-  template <class T> struct hash;
-  template <class... Types> struct hash<variant<Types...>>;
-  template <> struct hash<monostate>;
-
-} // namespace std
-
-*/
-
-#include <cstddef>
-#include <exception>
-#include <functional>
-#include <initializer_list>
-#include <new>
-#include <type_traits>
-#include <utility>
-
-// Empty namespace, so it is guaranteed to exist before aliasing it as mpark
-namespace kwiver {
-
-namespace vital {}
-
-} // namespace kwiver
-
-namespace mpark = kwiver::vital;
-
-#include "config.hpp"
-#include "lib.hpp"
-#include "in_place.hpp"
-
-namespace kwiver {
-namespace vital{
-
-#ifdef MPARK_RETURN_TYPE_DEDUCTION
-
-#define AUTO auto
-#define AUTO_RETURN(...) { return __VA_ARGS__; }
-
-#define AUTO_REFREF auto &&
-#define AUTO_REFREF_RETURN(...) { return __VA_ARGS__; }
-
-#define DECLTYPE_AUTO decltype(auto)
-#define DECLTYPE_AUTO_RETURN(...) { return __VA_ARGS__; }
-
-#else
-
-#define AUTO auto
-#define AUTO_RETURN(...) \
-  -> lib::decay_t<decltype(__VA_ARGS__)> { return __VA_ARGS__; }
-
-#define AUTO_REFREF auto
-#define AUTO_REFREF_RETURN(...)                                           \
-  -> decltype((__VA_ARGS__)) {                                            \
-    static_assert(std::is_reference<decltype((__VA_ARGS__))>::value, ""); \
-    return __VA_ARGS__;                                                   \
-  }
-
-#define DECLTYPE_AUTO auto
-#define DECLTYPE_AUTO_RETURN(...) \
-  -> decltype(__VA_ARGS__) { return __VA_ARGS__; }
-
-#endif
-
-  class bad_variant_access : public std::exception {
-    public:
-    virtual const char *what() const noexcept override { return "bad_variant_access"; }
-  };
-
-  [[noreturn]] inline void throw_bad_variant_access() {
-#ifdef MPARK_EXCEPTIONS
-    throw bad_variant_access{};
-#else
-    std::terminate();
-#ifdef MPARK_BUILTIN_UNREACHABLE
-    __builtin_unreachable();
-#endif
-#endif
-  }
-
-  template <typename... Ts>
-  class variant;
-
-  template <typename T>
-  struct variant_size;
-
-#ifdef MPARK_VARIABLE_TEMPLATES
-  template <typename T>
-  constexpr std::size_t variant_size_v = variant_size<T>::value;
-#endif
-
-  template <typename T>
-  struct variant_size<const T> : variant_size<T> {};
-
-  template <typename T>
-  struct variant_size<volatile T> : variant_size<T> {};
-
-  template <typename T>
-  struct variant_size<const volatile T> : variant_size<T> {};
-
-  template <typename... Ts>
-  struct variant_size<variant<Ts...>> : lib::size_constant<sizeof...(Ts)> {};
-
-  template <std::size_t I, typename T>
-  struct variant_alternative;
-
-  template <std::size_t I, typename T>
-  using variant_alternative_t = typename variant_alternative<I, T>::type;
-
-  template <std::size_t I, typename T>
-  struct variant_alternative<I, const T>
-      : std::add_const<variant_alternative_t<I, T>> {};
-
-  template <std::size_t I, typename T>
-  struct variant_alternative<I, volatile T>
-      : std::add_volatile<variant_alternative_t<I, T>> {};
-
-  template <std::size_t I, typename T>
-  struct variant_alternative<I, const volatile T>
-      : std::add_cv<variant_alternative_t<I, T>> {};
-
-  template <std::size_t I, typename... Ts>
-  struct variant_alternative<I, variant<Ts...>> {
-    static_assert(I < sizeof...(Ts),
-                  "Index out of bounds in std::variant_alternative<>");
-    using type = lib::type_pack_element_t<I, Ts...>;
-  };
-
-  constexpr std::size_t variant_npos = static_cast<std::size_t>(-1);
-
-  namespace mpark_detail {
-
-    constexpr std::size_t not_found = static_cast<std::size_t>(-1);
-    constexpr std::size_t ambiguous = static_cast<std::size_t>(-2);
-
-#ifdef MPARK_CPP14_CONSTEXPR
-    template <typename T, typename... Ts>
-    inline constexpr std::size_t find_index() {
-      constexpr lib::array<bool, sizeof...(Ts)> matches = {
-          {std::is_same<T, Ts>::value...}
-      };
-      std::size_t result = not_found;
-      for (std::size_t i = 0; i < sizeof...(Ts); ++i) {
-        if (matches[i]) {
-          if (result != not_found) {
-            return ambiguous;
-          }
-          result = i;
-        }
-      }
-      return result;
-    }
-#else
-    inline constexpr std::size_t find_index_impl(std::size_t result,
-                                                 std::size_t) {
-      return result;
-    }
-
-    template <typename... Bs>
-    inline constexpr std::size_t find_index_impl(std::size_t result,
-                                                 std::size_t idx,
-                                                 bool b,
-                                                 Bs... bs) {
-      return b ? (result != not_found ? ambiguous
-                                      : find_index_impl(idx, idx + 1, bs...))
-               : find_index_impl(result, idx + 1, bs...);
-    }
-
-    template <typename T, typename... Ts>
-    inline constexpr std::size_t find_index() {
-      return find_index_impl(not_found, 0, std::is_same<T, Ts>::value...);
-    }
-#endif
-
-    template <std::size_t I>
-    using find_index_sfinae_impl =
-        lib::enable_if_t<I != not_found && I != ambiguous,
-                         lib::size_constant<I>>;
-
-    template <typename T, typename... Ts>
-    using find_index_sfinae = find_index_sfinae_impl<find_index<T, Ts...>()>;
-
-    template <std::size_t I>
-    struct find_index_checked_impl : lib::size_constant<I> {
-      static_assert(I != not_found, "the specified type is not found.");
-      static_assert(I != ambiguous, "the specified type is ambiguous.");
-    };
-
-    template <typename T, typename... Ts>
-    using find_index_checked = find_index_checked_impl<find_index<T, Ts...>()>;
-
-    struct valueless_t {};
-
-    enum class Trait { TriviallyAvailable, Available, Unavailable };
-
-    template <typename T,
-              template <typename> class IsTriviallyAvailable,
-              template <typename> class IsAvailable>
-    inline constexpr Trait trait() {
-      return IsTriviallyAvailable<T>::value
-                 ? Trait::TriviallyAvailable
-                 : IsAvailable<T>::value ? Trait::Available
-                                         : Trait::Unavailable;
-    }
-
-#ifdef MPARK_CPP14_CONSTEXPR
-    template <typename... Traits>
-    inline constexpr Trait common_trait(Traits... traits_) {
-      Trait result = Trait::TriviallyAvailable;
-      for (Trait t : {traits_...}) {
-        if (static_cast<int>(t) > static_cast<int>(result)) {
-          result = t;
-        }
-      }
-      return result;
-    }
-#else
-    inline constexpr Trait common_trait_impl(Trait result) { return result; }
-
-    template <typename... Traits>
-    inline constexpr Trait common_trait_impl(Trait result,
-                                             Trait t,
-                                             Traits... ts) {
-      return static_cast<int>(t) > static_cast<int>(result)
-                 ? common_trait_impl(t, ts...)
-                 : common_trait_impl(result, ts...);
-    }
-
-    template <typename... Traits>
-    inline constexpr Trait common_trait(Traits... ts) {
-      return common_trait_impl(Trait::TriviallyAvailable, ts...);
-    }
-#endif
-
-    template <typename... Ts>
-    struct traits {
-      static constexpr Trait copy_constructible_trait =
-          common_trait(trait<Ts,
-                             lib::is_trivially_copy_constructible,
-                             std::is_copy_constructible>()...);
-
-      static constexpr Trait move_constructible_trait =
-          common_trait(trait<Ts,
-                             lib::is_trivially_move_constructible,
-                             std::is_move_constructible>()...);
-
-      static constexpr Trait copy_assignable_trait =
-          common_trait(copy_constructible_trait,
-                       trait<Ts,
-                             lib::is_trivially_copy_assignable,
-                             std::is_copy_assignable>()...);
-
-      static constexpr Trait move_assignable_trait =
-          common_trait(move_constructible_trait,
-                       trait<Ts,
-                             lib::is_trivially_move_assignable,
-                             std::is_move_assignable>()...);
-
-      static constexpr Trait destructible_trait =
-          common_trait(trait<Ts,
-                             std::is_trivially_destructible,
-                             std::is_destructible>()...);
-    };
-
-    namespace access {
-
-      struct recursive_union {
-#ifdef MPARK_RETURN_TYPE_DEDUCTION
-        template <typename V>
-        inline static constexpr auto &&get_alt(V &&v, in_place_index_t<0>) {
-          return lib::forward<V>(v).head_;
-        }
-
-        template <typename V, std::size_t I>
-        inline static constexpr auto &&get_alt(V &&v, in_place_index_t<I>) {
-          return get_alt(lib::forward<V>(v).tail_, in_place_index_t<I - 1>{});
-        }
-#else
-        template <std::size_t I, bool Dummy = true>
-        struct get_alt_impl {
-          template <typename V>
-          inline constexpr AUTO_REFREF operator()(V &&v) const
-            AUTO_REFREF_RETURN(get_alt_impl<I - 1>{}(lib::forward<V>(v).tail_))
-        };
-
-        template <bool Dummy>
-        struct get_alt_impl<0, Dummy> {
-          template <typename V>
-          inline constexpr AUTO_REFREF operator()(V &&v) const
-            AUTO_REFREF_RETURN(lib::forward<V>(v).head_)
-        };
-
-        template <typename V, std::size_t I>
-        inline static constexpr AUTO_REFREF get_alt(V &&v, in_place_index_t<I>)
-          AUTO_REFREF_RETURN(get_alt_impl<I>{}(lib::forward<V>(v)))
-#endif
-      };
-
-      struct base {
-        template <std::size_t I, typename V>
-        inline static constexpr AUTO_REFREF get_alt(V &&v)
-          AUTO_REFREF_RETURN(recursive_union::get_alt(
-              data(lib::forward<V>(v)), in_place_index_t<I>{}))
-      };
-
-      struct variant {
-        template <std::size_t I, typename V>
-        inline static constexpr AUTO_REFREF get_alt(V &&v)
-          AUTO_REFREF_RETURN(base::get_alt<I>(lib::forward<V>(v).impl_))
-      };
-
-    }  // namespace access
-
-    namespace visitation {
-
-      struct base {
-        template <typename T>
-        inline static constexpr const T &at(const T &elem) noexcept {
-          return elem;
-        }
-
-        template <typename T, std::size_t N, typename... Is>
-        inline static constexpr const lib::remove_all_extents_t<T> &at(
-            const lib::array<T, N> &elems, std::size_t i, Is... is) noexcept {
-          return at(elems[i], is...);
-        }
-
-        template <typename F, typename... Fs>
-        inline static constexpr int visit_visitor_return_type_check() {
-          static_assert(lib::all<std::is_same<F, Fs>::value...>::value,
-                        "`mpark::visit` requires the visitor to have a single "
-                        "return type.");
-          return 0;
-        }
-
-        template <typename... Fs>
-        inline static constexpr lib::array<
-            lib::common_type_t<lib::decay_t<Fs>...>,
-            sizeof...(Fs)>
-        make_farray(Fs &&... fs) {
-          using result = lib::array<lib::common_type_t<lib::decay_t<Fs>...>,
-                                    sizeof...(Fs)>;
-          return visit_visitor_return_type_check<lib::decay_t<Fs>...>(),
-                 result{{lib::forward<Fs>(fs)...}};
-        }
-
-        template <std::size_t... Is>
-        struct dispatcher {
-          template <typename F, typename... Vs>
-          struct impl {
-            inline static constexpr DECLTYPE_AUTO dispatch(F f, Vs... vs)
-              DECLTYPE_AUTO_RETURN(lib::invoke(
-                  static_cast<F>(f),
-                  access::base::get_alt<Is>(static_cast<Vs>(vs))...))
-          };
-        };
-
-        template <typename F, typename... Vs, std::size_t... Is>
-        inline static constexpr AUTO make_dispatch(lib::index_sequence<Is...>)
-          AUTO_RETURN(&dispatcher<Is...>::template impl<F, Vs...>::dispatch)
-
-        template <std::size_t I, typename F, typename... Vs>
-        inline static constexpr AUTO make_fdiagonal_impl()
-          AUTO_RETURN(make_dispatch<F, Vs...>(
-              lib::index_sequence<lib::indexed_type<I, Vs>::value...>{}))
-
-        template <typename F, typename... Vs, std::size_t... Is>
-        inline static constexpr AUTO make_fdiagonal_impl(
-            lib::index_sequence<Is...>)
-          AUTO_RETURN(make_farray(make_fdiagonal_impl<Is, F, Vs...>()...))
-
-        template <typename F, typename V, typename... Vs>
-        inline static constexpr /* auto * */ auto make_fdiagonal()
-            -> decltype(make_fdiagonal_impl<F, V, Vs...>(
-                lib::make_index_sequence<lib::decay_t<V>::size()>{})) {
-          static_assert(lib::all<(lib::decay_t<V>::size() ==
-                                  lib::decay_t<Vs>::size())...>::value,
-                        "all of the variants must be the same size.");
-          return make_fdiagonal_impl<F, V, Vs...>(
-              lib::make_index_sequence<lib::decay_t<V>::size()>{});
-        }
-
-#ifdef MPARK_RETURN_TYPE_DEDUCTION
-        template <typename F, typename... Vs, typename Is>
-        inline static constexpr auto make_fmatrix_impl(Is is) {
-          return make_dispatch<F, Vs...>(is);
-        }
-
-        template <typename F,
-                  typename... Vs,
-                  typename Is,
-                  std::size_t... Js,
-                  typename... Ls>
-        inline static constexpr auto make_fmatrix_impl(
-            Is, lib::index_sequence<Js...>, Ls... ls) {
-          return make_farray(make_fmatrix_impl<F, Vs...>(
-              lib::push_back_t<Is, Js>{}, ls...)...);
-        }
-
-        template <typename F, typename... Vs>
-        inline static constexpr auto make_fmatrix() {
-          return make_fmatrix_impl<F, Vs...>(
-              lib::index_sequence<>{},
-              lib::make_index_sequence<lib::decay_t<Vs>::size()>{}...);
-        }
-#else
-        template <typename F, typename... Vs>
-        struct make_fmatrix_impl {
-          template <typename...>
-          struct impl;
-
-          template <typename Is>
-          struct impl<Is> {
-            inline constexpr AUTO operator()() const
-              AUTO_RETURN(make_dispatch<F, Vs...>(Is{}))
-          };
-
-          template <typename Is, std::size_t... Js, typename... Ls>
-          struct impl<Is, lib::index_sequence<Js...>, Ls...> {
-            inline constexpr AUTO operator()() const
-              AUTO_RETURN(
-                  make_farray(impl<lib::push_back_t<Is, Js>, Ls...>{}()...))
-          };
-        };
-
-        template <typename F, typename... Vs>
-        inline static constexpr AUTO make_fmatrix()
-          AUTO_RETURN(
-              typename make_fmatrix_impl<F, Vs...>::template impl<
-                  lib::index_sequence<>,
-                  lib::make_index_sequence<lib::decay_t<Vs>::size()>...>{}())
-#endif
-      };  // namespace base
-
-      template <typename F, typename... Vs>
-      using FDiagonal = decltype(base::make_fdiagonal<F, Vs...>());
-
-      template <typename F, typename... Vs>
-      struct fdiagonal {
-#ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable : 4268)
-#endif
-        static constexpr FDiagonal<F, Vs...> value =
-            base::make_fdiagonal<F, Vs...>();
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
-      };
-
-      template <typename F, typename... Vs>
-      constexpr FDiagonal<F, Vs...> fdiagonal<F, Vs...>::value;
-
-      template <typename F, typename... Vs>
-      using FMatrix = decltype(base::make_fmatrix<F, Vs...>());
-
-      template <typename F, typename... Vs>
-      struct fmatrix {
-#ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable : 4268)
-#endif
-        static constexpr FMatrix<F, Vs...> value =
-            base::make_fmatrix<F, Vs...>();
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
-      };
-
-      template <typename F, typename... Vs>
-      constexpr FMatrix<F, Vs...> fmatrix<F, Vs...>::value;
-
-      struct alt {
-        template <typename Visitor, typename... Vs>
-        inline static constexpr DECLTYPE_AUTO visit_alt_at(std::size_t index,
-                                                           Visitor &&visitor,
-                                                           Vs &&... vs)
-          DECLTYPE_AUTO_RETURN(base::at(
-              fdiagonal<Visitor &&,
-                        decltype(as_base(lib::forward<Vs>(vs)))...>::value,
-              index)(lib::forward<Visitor>(visitor),
-                     as_base(lib::forward<Vs>(vs))...))
-
-        template <typename Visitor, typename... Vs>
-        inline static constexpr DECLTYPE_AUTO visit_alt(Visitor &&visitor,
-                                                        Vs &&... vs)
-          DECLTYPE_AUTO_RETURN(base::at(
-              fmatrix<Visitor &&,
-                      decltype(as_base(lib::forward<Vs>(vs)))...>::value,
-              vs.index()...)(lib::forward<Visitor>(visitor),
-                             as_base(lib::forward<Vs>(vs))...))
-      };
-
-      struct variant {
-        private:
-        template <typename Visitor, typename... Values>
-        struct visit_exhaustive_visitor_check {
-          static_assert(
-              lib::is_invocable<Visitor, Values...>::value,
-              "`mpark::visit` requires the visitor to be exhaustive.");
-
-#ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable : 4100)
-#endif
-          inline constexpr DECLTYPE_AUTO operator()(Visitor &&visitor,
-                                                    Values &&... values) const
-            DECLTYPE_AUTO_RETURN(lib::invoke(lib::forward<Visitor>(visitor),
-                                             lib::forward<Values>(values)...))
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
-        };
-
-        template <typename Visitor>
-        struct value_visitor {
-          Visitor &&visitor_;
-
-          template <typename... Alts>
-          inline constexpr DECLTYPE_AUTO operator()(Alts &&... alts) const
-            DECLTYPE_AUTO_RETURN(
-                visit_exhaustive_visitor_check<
-                    Visitor,
-                    decltype((lib::forward<Alts>(alts).value))...>{}(
-                    lib::forward<Visitor>(visitor_),
-                    lib::forward<Alts>(alts).value...))
-        };
-
-        template <typename Visitor>
-        inline static constexpr AUTO make_value_visitor(Visitor &&visitor)
-          AUTO_RETURN(value_visitor<Visitor>{lib::forward<Visitor>(visitor)})
-
-        public:
-        template <typename Visitor, typename... Vs>
-        inline static constexpr DECLTYPE_AUTO visit_alt_at(std::size_t index,
-                                                           Visitor &&visitor,
-                                                           Vs &&... vs)
-          DECLTYPE_AUTO_RETURN(
-              alt::visit_alt_at(index,
-                                lib::forward<Visitor>(visitor),
-                                lib::forward<Vs>(vs).impl_...))
-
-        template <typename Visitor, typename... Vs>
-        inline static constexpr DECLTYPE_AUTO visit_alt(Visitor &&visitor,
-                                                        Vs &&... vs)
-          DECLTYPE_AUTO_RETURN(alt::visit_alt(lib::forward<Visitor>(visitor),
-                                              lib::forward<Vs>(vs).impl_...))
-
-        template <typename Visitor, typename... Vs>
-        inline static constexpr DECLTYPE_AUTO visit_value_at(std::size_t index,
-                                                             Visitor &&visitor,
-                                                             Vs &&... vs)
-          DECLTYPE_AUTO_RETURN(
-              visit_alt_at(index,
-                           make_value_visitor(lib::forward<Visitor>(visitor)),
-                           lib::forward<Vs>(vs)...))
-
-        template <typename Visitor, typename... Vs>
-        inline static constexpr DECLTYPE_AUTO visit_value(Visitor &&visitor,
-                                                          Vs &&... vs)
-          DECLTYPE_AUTO_RETURN(
-              visit_alt(make_value_visitor(lib::forward<Visitor>(visitor)),
-                        lib::forward<Vs>(vs)...))
-      };
-
-    }  // namespace visitation
-
-    template <std::size_t Index, typename T>
-    struct alt {
-      using value_type = T;
-
-#ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable : 4244)
-#endif
-      template <typename... Args>
-      inline explicit constexpr alt(in_place_t, Args &&... args)
-          : value(lib::forward<Args>(args)...) {}
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
-
-      T value;
-    };
-
-    template <Trait DestructibleTrait, std::size_t Index, typename... Ts>
-    union recursive_union;
-
-    template <Trait DestructibleTrait, std::size_t Index>
-    union recursive_union<DestructibleTrait, Index> {};
-
-#define MPARK_VARIANT_RECURSIVE_UNION(destructible_trait, destructor)      \
-  template <std::size_t Index, typename T, typename... Ts>                 \
-  union recursive_union<destructible_trait, Index, T, Ts...> {             \
-    public:                                                                \
-    inline explicit constexpr recursive_union(valueless_t) noexcept        \
-        : dummy_{} {}                                                      \
-                                                                           \
-    template <typename... Args>                                            \
-    inline explicit constexpr recursive_union(in_place_index_t<0>,         \
-                                              Args &&... args)             \
-        : head_(in_place_t{}, lib::forward<Args>(args)...) {}              \
-                                                                           \
-    template <std::size_t I, typename... Args>                             \
-    inline explicit constexpr recursive_union(in_place_index_t<I>,         \
-                                              Args &&... args)             \
-        : tail_(in_place_index_t<I - 1>{}, lib::forward<Args>(args)...) {} \
-                                                                           \
-    recursive_union(const recursive_union &) = default;                    \
-    recursive_union(recursive_union &&) = default;                         \
-                                                                           \
-    destructor                                                             \
-                                                                           \
-    recursive_union &operator=(const recursive_union &) = default;         \
-    recursive_union &operator=(recursive_union &&) = default;              \
-                                                                           \
-    private:                                                               \
-    char dummy_;                                                           \
-    alt<Index, T> head_;                                                   \
-    recursive_union<destructible_trait, Index + 1, Ts...> tail_;           \
-                                                                           \
-    friend struct access::recursive_union;                                 \
-  }
-
-    MPARK_VARIANT_RECURSIVE_UNION(Trait::TriviallyAvailable,
-                                  ~recursive_union() = default;);
-    MPARK_VARIANT_RECURSIVE_UNION(Trait::Available,
-                                  ~recursive_union() {});
-    MPARK_VARIANT_RECURSIVE_UNION(Trait::Unavailable,
-                                  ~recursive_union() = delete;);
-
-#undef MPARK_VARIANT_RECURSIVE_UNION
-
-    using index_t = unsigned int;
-
-    template <Trait DestructibleTrait, typename... Ts>
-    class base {
-      public:
-      inline explicit constexpr base(valueless_t tag) noexcept
-          : data_(tag), index_(static_cast<index_t>(-1)) {}
-
-      template <std::size_t I, typename... Args>
-      inline explicit constexpr base(in_place_index_t<I>, Args &&... args)
-          : data_(in_place_index_t<I>{}, lib::forward<Args>(args)...),
-            index_(I) {}
-
-      inline constexpr bool valueless_by_exception() const noexcept {
-        return index_ == static_cast<index_t>(-1);
-      }
-
-      inline constexpr std::size_t index() const noexcept {
-        return valueless_by_exception() ? variant_npos : index_;
-      }
-
-      protected:
-      using data_t = recursive_union<DestructibleTrait, 0, Ts...>;
-
-      friend inline constexpr base &as_base(base &b) { return b; }
-      friend inline constexpr const base &as_base(const base &b) { return b; }
-      friend inline constexpr base &&as_base(base &&b) { return lib::move(b); }
-      friend inline constexpr const base &&as_base(const base &&b) { return lib::move(b); }
-
-      friend inline constexpr data_t &data(base &b) { return b.data_; }
-      friend inline constexpr const data_t &data(const base &b) { return b.data_; }
-      friend inline constexpr data_t &&data(base &&b) { return lib::move(b).data_; }
-      friend inline constexpr const data_t &&data(const base &&b) { return lib::move(b).data_; }
-
-      inline static constexpr std::size_t size() { return sizeof...(Ts); }
-
-      data_t data_;
-      index_t index_;
-
-      friend struct access::base;
-      friend struct visitation::base;
-    };
-
-    struct dtor {
-#ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable : 4100)
-#endif
-      template <typename Alt>
-      inline void operator()(Alt &alt) const noexcept { alt.~Alt(); }
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
-    };
-
-#if defined(_MSC_VER) && _MSC_VER < 1910
-#define INHERITING_CTOR(type, base)               \
-  template <typename... Args>                     \
-  inline explicit constexpr type(Args &&... args) \
-      : base(lib::forward<Args>(args)...) {}
-#else
-#define INHERITING_CTOR(type, base) using base::base;
-#endif
-
-    template <typename Traits, Trait = Traits::destructible_trait>
-    class destructor;
-
-#define MPARK_VARIANT_DESTRUCTOR(destructible_trait, definition, destroy) \
-  template <typename... Ts>                                               \
-  class destructor<traits<Ts...>, destructible_trait>                     \
-      : public base<destructible_trait, Ts...> {                          \
-    using super = base<destructible_trait, Ts...>;                        \
-                                                                          \
-    public:                                                               \
-    INHERITING_CTOR(destructor, super)                                    \
-    using super::operator=;                                               \
-                                                                          \
-    destructor(const destructor &) = default;                             \
-    destructor(destructor &&) = default;                                  \
-    definition                                                            \
-    destructor &operator=(const destructor &) = default;                  \
-    destructor &operator=(destructor &&) = default;                       \
-                                                                          \
-    protected:                                                            \
-    destroy                                                               \
-  }
-
-    MPARK_VARIANT_DESTRUCTOR(
-        Trait::TriviallyAvailable,
-        ~destructor() = default;,
-        inline void destroy() noexcept {
-          this->index_ = static_cast<index_t>(-1);
-        });
-
-    MPARK_VARIANT_DESTRUCTOR(
-        Trait::Available,
-        ~destructor() { destroy(); },
-        inline void destroy() noexcept {
-          if (!this->valueless_by_exception()) {
-            visitation::alt::visit_alt(dtor{}, *this);
-          }
-          this->index_ = static_cast<index_t>(-1);
-        });
-
-    MPARK_VARIANT_DESTRUCTOR(
-        Trait::Unavailable,
-        ~destructor() = delete;,
-        inline void destroy() noexcept = delete;);
-
-#undef MPARK_VARIANT_DESTRUCTOR
-
-    template <typename Traits>
-    class constructor : public destructor<Traits> {
-      using super = destructor<Traits>;
-
-      public:
-      INHERITING_CTOR(constructor, super)
-      using super::operator=;
-
-      protected:
-#ifndef MPARK_GENERIC_LAMBDAS
-      struct ctor {
-        template <typename LhsAlt, typename RhsAlt>
-        inline void operator()(LhsAlt &lhs_alt, RhsAlt &&rhs_alt) const {
-          constructor::construct_alt(lhs_alt,
-                                     lib::forward<RhsAlt>(rhs_alt).value);
-        }
-      };
-#endif
-
-      template <std::size_t I, typename T, typename... Args>
-      inline static T &construct_alt(alt<I, T> &a, Args &&... args) {
-        ::new (static_cast<void *>(lib::addressof(a)))
-            alt<I, T>(in_place_t{}, lib::forward<Args>(args)...);
-        return a.value;
-      }
-
-      template <typename Rhs>
-      inline static void generic_construct(constructor &lhs, Rhs &&rhs) {
-        lhs.destroy();
-        if (!rhs.valueless_by_exception()) {
-          visitation::alt::visit_alt_at(
-              rhs.index(),
-#ifdef MPARK_GENERIC_LAMBDAS
-              [](auto &lhs_alt, auto &&rhs_alt) {
-                constructor::construct_alt(
-                    lhs_alt, lib::forward<decltype(rhs_alt)>(rhs_alt).value);
-              }
-#else
-              ctor{}
-#endif
-              ,
-              lhs,
-              lib::forward<Rhs>(rhs));
-          lhs.index_ = rhs.index_;
-        }
-      }
-    };
-
-    template <typename Traits, Trait = Traits::move_constructible_trait>
-    class move_constructor;
-
-#define MPARK_VARIANT_MOVE_CONSTRUCTOR(move_constructible_trait, definition) \
-  template <typename... Ts>                                                  \
-  class move_constructor<traits<Ts...>, move_constructible_trait>            \
-      : public constructor<traits<Ts...>> {                                  \
-    using super = constructor<traits<Ts...>>;                                \
-                                                                             \
-    public:                                                                  \
-    INHERITING_CTOR(move_constructor, super)                                 \
-    using super::operator=;                                                  \
-                                                                             \
-    move_constructor(const move_constructor &) = default;                    \
-    definition                                                               \
-    ~move_constructor() = default;                                           \
-    move_constructor &operator=(const move_constructor &) = default;         \
-    move_constructor &operator=(move_constructor &&) = default;              \
-  }
-
-    MPARK_VARIANT_MOVE_CONSTRUCTOR(
-        Trait::TriviallyAvailable,
-        move_constructor(move_constructor &&that) = default;);
-
-    MPARK_VARIANT_MOVE_CONSTRUCTOR(
-        Trait::Available,
-        move_constructor(move_constructor &&that) noexcept(
-            lib::all<std::is_nothrow_move_constructible<Ts>::value...>::value)
-            : move_constructor(valueless_t{}) {
-          this->generic_construct(*this, lib::move(that));
-        });
-
-    MPARK_VARIANT_MOVE_CONSTRUCTOR(
-        Trait::Unavailable,
-        move_constructor(move_constructor &&) = delete;);
-
-#undef MPARK_VARIANT_MOVE_CONSTRUCTOR
-
-    template <typename Traits, Trait = Traits::copy_constructible_trait>
-    class copy_constructor;
-
-#define MPARK_VARIANT_COPY_CONSTRUCTOR(copy_constructible_trait, definition) \
-  template <typename... Ts>                                                  \
-  class copy_constructor<traits<Ts...>, copy_constructible_trait>            \
-      : public move_constructor<traits<Ts...>> {                             \
-    using super = move_constructor<traits<Ts...>>;                           \
-                                                                             \
-    public:                                                                  \
-    INHERITING_CTOR(copy_constructor, super)                                 \
-    using super::operator=;                                                  \
-                                                                             \
-    definition                                                               \
-    copy_constructor(copy_constructor &&) = default;                         \
-    ~copy_constructor() = default;                                           \
-    copy_constructor &operator=(const copy_constructor &) = default;         \
-    copy_constructor &operator=(copy_constructor &&) = default;              \
-  }
-
-    MPARK_VARIANT_COPY_CONSTRUCTOR(
-        Trait::TriviallyAvailable,
-        copy_constructor(const copy_constructor &that) = default;);
-
-    MPARK_VARIANT_COPY_CONSTRUCTOR(
-        Trait::Available,
-        copy_constructor(const copy_constructor &that)
-            : copy_constructor(valueless_t{}) {
-          this->generic_construct(*this, that);
-        });
-
-    MPARK_VARIANT_COPY_CONSTRUCTOR(
-        Trait::Unavailable,
-        copy_constructor(const copy_constructor &) = delete;);
-
-#undef MPARK_VARIANT_COPY_CONSTRUCTOR
-
-    template <typename Traits>
-    class assignment : public copy_constructor<Traits> {
-      using super = copy_constructor<Traits>;
-
-      public:
-      INHERITING_CTOR(assignment, super)
-      using super::operator=;
-
-      template <std::size_t I, typename... Args>
-      inline /* auto & */ auto emplace(Args &&... args)
-          -> decltype(this->construct_alt(access::base::get_alt<I>(*this),
-                                          lib::forward<Args>(args)...)) {
-        this->destroy();
-        auto &result = this->construct_alt(access::base::get_alt<I>(*this),
-                                           lib::forward<Args>(args)...);
-        this->index_ = I;
-        return result;
-      }
-
-      protected:
-#ifndef MPARK_GENERIC_LAMBDAS
-      template <typename That>
-      struct assigner {
-        template <typename ThisAlt, typename ThatAlt>
-        inline void operator()(ThisAlt &this_alt, ThatAlt &&that_alt) const {
-          self->assign_alt(this_alt, lib::forward<ThatAlt>(that_alt).value);
-        }
-        assignment *self;
-      };
-#endif
-
-      template <std::size_t I, typename T, typename Arg>
-      inline void assign_alt(alt<I, T> &a, Arg &&arg) {
-        if (this->index() == I) {
-#ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable : 4244)
-#endif
-          a.value = lib::forward<Arg>(arg);
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
-        } else {
-          struct {
-            void operator()(std::true_type) const {
-              this_->emplace<I>(lib::forward<Arg>(arg_));
-            }
-            void operator()(std::false_type) const {
-              this_->emplace<I>(T(lib::forward<Arg>(arg_)));
-            }
-            assignment *this_;
-            Arg &&arg_;
-          } impl{this, lib::forward<Arg>(arg)};
-          impl(lib::bool_constant<
-                   std::is_nothrow_constructible<T, Arg>::value ||
-                   !std::is_nothrow_move_constructible<T>::value>{});
-        }
-      }
-
-      template <typename That>
-      inline void generic_assign(That &&that) {
-        if (this->valueless_by_exception() && that.valueless_by_exception()) {
-          // do nothing.
-        } else if (that.valueless_by_exception()) {
-          this->destroy();
-        } else {
-          visitation::alt::visit_alt_at(
-              that.index(),
-#ifdef MPARK_GENERIC_LAMBDAS
-              [this](auto &this_alt, auto &&that_alt) {
-                this->assign_alt(
-                    this_alt, lib::forward<decltype(that_alt)>(that_alt).value);
-              }
-#else
-              assigner<That>{this}
-#endif
-              ,
-              *this,
-              lib::forward<That>(that));
-        }
-      }
-    };
-
-    template <typename Traits, Trait = Traits::move_assignable_trait>
-    class move_assignment;
-
-#define MPARK_VARIANT_MOVE_ASSIGNMENT(move_assignable_trait, definition) \
-  template <typename... Ts>                                              \
-  class move_assignment<traits<Ts...>, move_assignable_trait>            \
-      : public assignment<traits<Ts...>> {                               \
-    using super = assignment<traits<Ts...>>;                             \
-                                                                         \
-    public:                                                              \
-    INHERITING_CTOR(move_assignment, super)                              \
-    using super::operator=;                                              \
-                                                                         \
-    move_assignment(const move_assignment &) = default;                  \
-    move_assignment(move_assignment &&) = default;                       \
-    ~move_assignment() = default;                                        \
-    move_assignment &operator=(const move_assignment &) = default;       \
-    definition                                                           \
-  }
-
-    MPARK_VARIANT_MOVE_ASSIGNMENT(
-        Trait::TriviallyAvailable,
-        move_assignment &operator=(move_assignment &&that) = default;);
-
-    MPARK_VARIANT_MOVE_ASSIGNMENT(
-        Trait::Available,
-        move_assignment &
-        operator=(move_assignment &&that) noexcept(
-            lib::all<(std::is_nothrow_move_constructible<Ts>::value &&
-                      std::is_nothrow_move_assignable<Ts>::value)...>::value) {
-          this->generic_assign(lib::move(that));
-          return *this;
-        });
-
-    MPARK_VARIANT_MOVE_ASSIGNMENT(
-        Trait::Unavailable,
-        move_assignment &operator=(move_assignment &&) = delete;);
-
-#undef MPARK_VARIANT_MOVE_ASSIGNMENT
-
-    template <typename Traits, Trait = Traits::copy_assignable_trait>
-    class copy_assignment;
-
-#define MPARK_VARIANT_COPY_ASSIGNMENT(copy_assignable_trait, definition) \
-  template <typename... Ts>                                              \
-  class copy_assignment<traits<Ts...>, copy_assignable_trait>            \
-      : public move_assignment<traits<Ts...>> {                          \
-    using super = move_assignment<traits<Ts...>>;                        \
-                                                                         \
-    public:                                                              \
-    INHERITING_CTOR(copy_assignment, super)                              \
-    using super::operator=;                                              \
-                                                                         \
-    copy_assignment(const copy_assignment &) = default;                  \
-    copy_assignment(copy_assignment &&) = default;                       \
-    ~copy_assignment() = default;                                        \
-    definition                                                           \
-    copy_assignment &operator=(copy_assignment &&) = default;            \
-  }
-
-    MPARK_VARIANT_COPY_ASSIGNMENT(
-        Trait::TriviallyAvailable,
-        copy_assignment &operator=(const copy_assignment &that) = default;);
-
-    MPARK_VARIANT_COPY_ASSIGNMENT(
-        Trait::Available,
-        copy_assignment &operator=(const copy_assignment &that) {
-          this->generic_assign(that);
-          return *this;
-        });
-
-    MPARK_VARIANT_COPY_ASSIGNMENT(
-        Trait::Unavailable,
-        copy_assignment &operator=(const copy_assignment &) = delete;);
-
-#undef MPARK_VARIANT_COPY_ASSIGNMENT
-
-    template <typename... Ts>
-    class impl : public copy_assignment<traits<Ts...>> {
-      using super = copy_assignment<traits<Ts...>>;
-
-      public:
-      INHERITING_CTOR(impl, super)
-      using super::operator=;
-
-      template <std::size_t I, typename Arg>
-      inline void assign(Arg &&arg) {
-        this->assign_alt(access::base::get_alt<I>(*this),
-                         lib::forward<Arg>(arg));
-      }
-
-      inline void swap(impl &that) {
-        if (this->valueless_by_exception() && that.valueless_by_exception()) {
-          // do nothing.
-        } else if (this->index() == that.index()) {
-          visitation::alt::visit_alt_at(this->index(),
-#ifdef MPARK_GENERIC_LAMBDAS
-                                        [](auto &this_alt, auto &that_alt) {
-                                          using std::swap;
-                                          swap(this_alt.value,
-                                               that_alt.value);
-                                        }
-#else
-                                        swapper{}
-#endif
-                                        ,
-                                        *this,
-                                        that);
-        } else {
-          impl *lhs = this;
-          impl *rhs = lib::addressof(that);
-          if (lhs->move_nothrow() && !rhs->move_nothrow()) {
-            std::swap(lhs, rhs);
-          }
-          impl tmp(lib::move(*rhs));
-#ifdef MPARK_EXCEPTIONS
-          // EXTENSION: When the move construction of `lhs` into `rhs` throws
-          // and `tmp` is nothrow move constructible then we move `tmp` back
-          // into `rhs` and provide the strong exception safety guarantee.
-          try {
-            this->generic_construct(*rhs, lib::move(*lhs));
-          } catch (...) {
-            if (tmp.move_nothrow()) {
-              this->generic_construct(*rhs, lib::move(tmp));
-            }
-            throw;
-          }
-#else
-          this->generic_construct(*rhs, lib::move(*lhs));
-#endif
-          this->generic_construct(*lhs, lib::move(tmp));
-        }
-      }
-
-      private:
-#ifndef MPARK_GENERIC_LAMBDAS
-      struct swapper {
-        template <typename ThisAlt, typename ThatAlt>
-        inline void operator()(ThisAlt &this_alt, ThatAlt &that_alt) const {
-          using std::swap;
-          swap(this_alt.value, that_alt.value);
-        }
-      };
-#endif
-
-      inline constexpr bool move_nothrow() const {
-        return this->valueless_by_exception() ||
-               lib::array<bool, sizeof...(Ts)>{
-                   {std::is_nothrow_move_constructible<Ts>::value...}
-               }[this->index()];
-      }
-    };
-
-    template <std::size_t I, typename T>
-    struct overload_leaf {
-      using F = lib::size_constant<I> (*)(T);
-      operator F() const { return nullptr; }
-    };
-
-    template <typename... Ts>
-    struct overload_impl {
-      private:
-      template <typename>
-      struct impl;
-
-      template <std::size_t... Is>
-      struct impl<lib::index_sequence<Is...>> : overload_leaf<Is, Ts>... {};
-
-      public:
-      using type = impl<lib::index_sequence_for<Ts...>>;
-    };
-
-    template <typename... Ts>
-    using overload = typename overload_impl<Ts...>::type;
-
-    template <typename T, typename... Ts>
-    using best_match = lib::invoke_result_t<overload<Ts...>, T &&>;
-
-    template <typename 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 {};
-
-    template <typename T>
-    struct is_in_place_type : std::false_type {};
-
-    template <typename T>
-    struct is_in_place_type<in_place_type_t<T>> : std::true_type {};
-
-  }  // mpark_detail
-
-  template <typename... Ts>
-  class variant {
-    static_assert(0 < sizeof...(Ts),
-                  "variant must consist of at least one alternative.");
-
-    static_assert(lib::all<!std::is_array<Ts>::value...>::value,
-                  "variant can not have an array type as an alternative.");
-
-    static_assert(lib::all<!std::is_reference<Ts>::value...>::value,
-                  "variant can not have a reference type as an alternative.");
-
-    static_assert(lib::all<!std::is_void<Ts>::value...>::value,
-                  "variant can not have a void type as an alternative.");
-
-    public:
-    template <
-        typename Front = lib::type_pack_element_t<0, Ts...>,
-        lib::enable_if_t<std::is_default_constructible<Front>::value, int> = 0>
-    inline constexpr variant() noexcept(
-        std::is_nothrow_default_constructible<Front>::value)
-        : impl_(in_place_index_t<0>{}) {}
-
-    variant(const variant &) = default;
-    variant(variant &&) = default;
-
-    template <
-        typename Arg,
-        typename Decayed = lib::decay_t<Arg>,
-        lib::enable_if_t<!std::is_same<Decayed, variant>::value, int> = 0,
-        lib::enable_if_t<!mpark_detail::is_in_place_index<Decayed>::value, int> = 0,
-        lib::enable_if_t<!mpark_detail::is_in_place_type<Decayed>::value, int> = 0,
-        std::size_t I = mpark_detail::best_match<Arg, Ts...>::value,
-        typename T = lib::type_pack_element_t<I, Ts...>,
-        lib::enable_if_t<std::is_constructible<T, Arg>::value, int> = 0>
-    inline constexpr variant(Arg &&arg) noexcept(
-        std::is_nothrow_constructible<T, Arg>::value)
-        : impl_(in_place_index_t<I>{}, lib::forward<Arg>(arg)) {}
-
-    template <
-        std::size_t I,
-        typename... Args,
-        typename T = lib::type_pack_element_t<I, Ts...>,
-        lib::enable_if_t<std::is_constructible<T, Args...>::value, int> = 0>
-    inline explicit constexpr variant(
-        in_place_index_t<I>,
-        Args &&... args) noexcept(std::is_nothrow_constructible<T,
-                                                                Args...>::value)
-        : impl_(in_place_index_t<I>{}, lib::forward<Args>(args)...) {}
-
-    template <
-        std::size_t I,
-        typename Up,
-        typename... Args,
-        typename T = lib::type_pack_element_t<I, Ts...>,
-        lib::enable_if_t<std::is_constructible<T,
-                                               std::initializer_list<Up> &,
-                                               Args...>::value,
-                         int> = 0>
-    inline explicit constexpr variant(
-        in_place_index_t<I>,
-        std::initializer_list<Up> il,
-        Args &&... args) noexcept(std::
-                                      is_nothrow_constructible<
-                                          T,
-                                          std::initializer_list<Up> &,
-                                          Args...>::value)
-        : impl_(in_place_index_t<I>{}, il, lib::forward<Args>(args)...) {}
-
-    template <
-        typename T,
-        typename... Args,
-        std::size_t I = mpark_detail::find_index_sfinae<T, Ts...>::value,
-        lib::enable_if_t<std::is_constructible<T, Args...>::value, int> = 0>
-    inline explicit constexpr variant(
-        in_place_type_t<T>,
-        Args &&... args) noexcept(std::is_nothrow_constructible<T,
-                                                                Args...>::value)
-        : impl_(in_place_index_t<I>{}, lib::forward<Args>(args)...) {}
-
-    template <
-        typename T,
-        typename Up,
-        typename... Args,
-        std::size_t I = mpark_detail::find_index_sfinae<T, Ts...>::value,
-        lib::enable_if_t<std::is_constructible<T,
-                                               std::initializer_list<Up> &,
-                                               Args...>::value,
-                         int> = 0>
-    inline explicit constexpr variant(
-        in_place_type_t<T>,
-        std::initializer_list<Up> il,
-        Args &&... args) noexcept(std::
-                                      is_nothrow_constructible<
-                                          T,
-                                          std::initializer_list<Up> &,
-                                          Args...>::value)
-        : impl_(in_place_index_t<I>{}, il, lib::forward<Args>(args)...) {}
-
-    ~variant() = default;
-
-    variant &operator=(const variant &) = default;
-    variant &operator=(variant &&) = default;
-
-    template <typename Arg,
-              lib::enable_if_t<!std::is_same<lib::decay_t<Arg>, variant>::value,
-                               int> = 0,
-              std::size_t I = mpark_detail::best_match<Arg, Ts...>::value,
-              typename T = lib::type_pack_element_t<I, Ts...>,
-              lib::enable_if_t<(std::is_assignable<T &, Arg>::value &&
-                                std::is_constructible<T, Arg>::value),
-                               int> = 0>
-    inline variant &operator=(Arg &&arg) noexcept(
-        (std::is_nothrow_assignable<T &, Arg>::value &&
-         std::is_nothrow_constructible<T, Arg>::value)) {
-      impl_.template assign<I>(lib::forward<Arg>(arg));
-      return *this;
-    }
-
-    template <
-        std::size_t I,
-        typename... Args,
-        typename T = lib::type_pack_element_t<I, Ts...>,
-        lib::enable_if_t<std::is_constructible<T, Args...>::value, int> = 0>
-    inline T &emplace(Args &&... args) {
-      return impl_.template emplace<I>(lib::forward<Args>(args)...);
-    }
-
-    template <
-        std::size_t I,
-        typename Up,
-        typename... Args,
-        typename T = lib::type_pack_element_t<I, Ts...>,
-        lib::enable_if_t<std::is_constructible<T,
-                                               std::initializer_list<Up> &,
-                                               Args...>::value,
-                         int> = 0>
-    inline T &emplace(std::initializer_list<Up> il, Args &&... args) {
-      return impl_.template emplace<I>(il, lib::forward<Args>(args)...);
-    }
-
-    template <
-        typename T,
-        typename... Args,
-        std::size_t I = mpark_detail::find_index_sfinae<T, Ts...>::value,
-        lib::enable_if_t<std::is_constructible<T, Args...>::value, int> = 0>
-    inline T &emplace(Args &&... args) {
-      return impl_.template emplace<I>(lib::forward<Args>(args)...);
-    }
-
-    template <
-        typename T,
-        typename Up,
-        typename... Args,
-        std::size_t I = mpark_detail::find_index_sfinae<T, Ts...>::value,
-        lib::enable_if_t<std::is_constructible<T,
-                                               std::initializer_list<Up> &,
-                                               Args...>::value,
-                         int> = 0>
-    inline T &emplace(std::initializer_list<Up> il, Args &&... args) {
-      return impl_.template emplace<I>(il, lib::forward<Args>(args)...);
-    }
-
-    inline constexpr bool valueless_by_exception() const noexcept {
-      return impl_.valueless_by_exception();
-    }
-
-    inline constexpr std::size_t index() const noexcept {
-      return impl_.index();
-    }
-
-    template <bool Dummy = true,
-              lib::enable_if_t<
-                  lib::all<Dummy,
-                           (lib::dependent_type<std::is_move_constructible<Ts>,
-                                                Dummy>::value &&
-                            lib::dependent_type<lib::is_swappable<Ts>,
-                                                Dummy>::value)...>::value,
-                  int> = 0>
-    inline void swap(variant &that) noexcept(
-        lib::all<(std::is_nothrow_move_constructible<Ts>::value &&
-                  lib::is_nothrow_swappable<Ts>::value)...>::value) {
-      impl_.swap(that.impl_);
-    }
-
-    private:
-    mpark_detail::impl<Ts...> impl_;
-
-    friend struct mpark_detail::access::variant;
-    friend struct mpark_detail::visitation::variant;
-  };
-
-  template <std::size_t I, typename... Ts>
-  inline constexpr bool holds_alternative(const variant<Ts...> &v) noexcept {
-    return v.index() == I;
-  }
-
-  template <typename T, typename... Ts>
-  inline constexpr bool holds_alternative(const variant<Ts...> &v) noexcept {
-    return holds_alternative<mpark_detail::find_index_checked<T, Ts...>::value>(v);
-  }
-
-  namespace mpark_detail {
-    template <std::size_t I, typename V>
-    struct generic_get_impl {
-      constexpr generic_get_impl(int) noexcept {}
-
-      constexpr AUTO_REFREF operator()(V &&v) const
-        AUTO_REFREF_RETURN(
-            access::variant::get_alt<I>(lib::forward<V>(v)).value)
-    };
-
-    template <std::size_t I, typename V>
-    inline constexpr AUTO_REFREF generic_get(V &&v)
-      AUTO_REFREF_RETURN(generic_get_impl<I, V>(
-          holds_alternative<I>(v) ? 0 : (throw_bad_variant_access(), 0))(
-          lib::forward<V>(v)))
-  }  // namespace mpark_detail
-
-  template <std::size_t I, typename... Ts>
-  inline constexpr variant_alternative_t<I, variant<Ts...>> &get(
-      variant<Ts...> &v) {
-    return mpark_detail::generic_get<I>(v);
-  }
-
-  template <std::size_t I, typename... Ts>
-  inline constexpr variant_alternative_t<I, variant<Ts...>> &&get(
-      variant<Ts...> &&v) {
-    return mpark_detail::generic_get<I>(lib::move(v));
-  }
-
-  template <std::size_t I, typename... Ts>
-  inline constexpr const variant_alternative_t<I, variant<Ts...>> &get(
-      const variant<Ts...> &v) {
-    return mpark_detail::generic_get<I>(v);
-  }
-
-  template <std::size_t I, typename... Ts>
-  inline constexpr const variant_alternative_t<I, variant<Ts...>> &&get(
-      const variant<Ts...> &&v) {
-    return mpark_detail::generic_get<I>(lib::move(v));
-  }
-
-  template <typename T, typename... Ts>
-  inline constexpr T &get(variant<Ts...> &v) {
-    return get<mpark_detail::find_index_checked<T, Ts...>::value>(v);
-  }
-
-  template <typename T, typename... Ts>
-  inline constexpr T &&get(variant<Ts...> &&v) {
-    return get<mpark_detail::find_index_checked<T, Ts...>::value>(lib::move(v));
-  }
-
-  template <typename T, typename... Ts>
-  inline constexpr const T &get(const variant<Ts...> &v) {
-    return get<mpark_detail::find_index_checked<T, Ts...>::value>(v);
-  }
-
-  template <typename T, typename... Ts>
-  inline constexpr const T &&get(const variant<Ts...> &&v) {
-    return get<mpark_detail::find_index_checked<T, Ts...>::value>(lib::move(v));
-  }
-
-  namespace mpark_detail {
-
-    template <std::size_t I, typename V>
-    inline constexpr /* auto * */ AUTO generic_get_if(V *v) noexcept
-      AUTO_RETURN(v && holds_alternative<I>(*v)
-                      ? lib::addressof(access::variant::get_alt<I>(*v).value)
-                      : nullptr)
-
-  }  // namespace mpark_detail
-
-  template <std::size_t I, typename... Ts>
-  inline constexpr lib::add_pointer_t<variant_alternative_t<I, variant<Ts...>>>
-  get_if(variant<Ts...> *v) noexcept {
-    return mpark_detail::generic_get_if<I>(v);
-  }
-
-  template <std::size_t I, typename... Ts>
-  inline constexpr lib::add_pointer_t<
-      const variant_alternative_t<I, variant<Ts...>>>
-  get_if(const variant<Ts...> *v) noexcept {
-    return mpark_detail::generic_get_if<I>(v);
-  }
-
-  template <typename T, typename... Ts>
-  inline constexpr lib::add_pointer_t<T>
-  get_if(variant<Ts...> *v) noexcept {
-    return get_if<mpark_detail::find_index_checked<T, Ts...>::value>(v);
-  }
-
-  template <typename T, typename... Ts>
-  inline constexpr lib::add_pointer_t<const T>
-  get_if(const variant<Ts...> *v) noexcept {
-    return get_if<mpark_detail::find_index_checked<T, Ts...>::value>(v);
-  }
-
-  template <typename... Ts>
-  inline constexpr bool operator==(const variant<Ts...> &lhs,
-                                   const variant<Ts...> &rhs) {
-    using mpark_detail::visitation::variant;
-    using lib::equal_to;
-#ifdef MPARK_CPP14_CONSTEXPR
-    if (lhs.index() != rhs.index()) return false;
-    if (lhs.valueless_by_exception()) return true;
-    return variant::visit_value_at(lhs.index(), equal_to{}, lhs, rhs);
-#else
-    return lhs.index() == rhs.index() &&
-           (lhs.valueless_by_exception() ||
-            variant::visit_value_at(lhs.index(), equal_to{}, lhs, rhs));
-#endif
-  }
-
-  template <typename... Ts>
-  inline constexpr bool operator!=(const variant<Ts...> &lhs,
-                                   const variant<Ts...> &rhs) {
-    using mpark_detail::visitation::variant;
-    using lib::not_equal_to;
-#ifdef MPARK_CPP14_CONSTEXPR
-    if (lhs.index() != rhs.index()) return true;
-    if (lhs.valueless_by_exception()) return false;
-    return variant::visit_value_at(lhs.index(), not_equal_to{}, lhs, rhs);
-#else
-    return lhs.index() != rhs.index() ||
-           (!lhs.valueless_by_exception() &&
-            variant::visit_value_at(lhs.index(), not_equal_to{}, lhs, rhs));
-#endif
-  }
-
-  template <typename... Ts>
-  inline constexpr bool operator<(const variant<Ts...> &lhs,
-                                  const variant<Ts...> &rhs) {
-    using mpark_detail::visitation::variant;
-    using lib::less;
-#ifdef MPARK_CPP14_CONSTEXPR
-    if (rhs.valueless_by_exception()) return false;
-    if (lhs.valueless_by_exception()) return true;
-    if (lhs.index() < rhs.index()) return true;
-    if (lhs.index() > rhs.index()) return false;
-    return variant::visit_value_at(lhs.index(), less{}, lhs, rhs);
-#else
-    return !rhs.valueless_by_exception() &&
-           (lhs.valueless_by_exception() || lhs.index() < rhs.index() ||
-            (lhs.index() == rhs.index() &&
-             variant::visit_value_at(lhs.index(), less{}, lhs, rhs)));
-#endif
-  }
-
-  template <typename... Ts>
-  inline constexpr bool operator>(const variant<Ts...> &lhs,
-                                  const variant<Ts...> &rhs) {
-    using mpark_detail::visitation::variant;
-    using lib::greater;
-#ifdef MPARK_CPP14_CONSTEXPR
-    if (lhs.valueless_by_exception()) return false;
-    if (rhs.valueless_by_exception()) return true;
-    if (lhs.index() > rhs.index()) return true;
-    if (lhs.index() < rhs.index()) return false;
-    return variant::visit_value_at(lhs.index(), greater{}, lhs, rhs);
-#else
-    return !lhs.valueless_by_exception() &&
-           (rhs.valueless_by_exception() || lhs.index() > rhs.index() ||
-            (lhs.index() == rhs.index() &&
-             variant::visit_value_at(lhs.index(), greater{}, lhs, rhs)));
-#endif
-  }
-
-  template <typename... Ts>
-  inline constexpr bool operator<=(const variant<Ts...> &lhs,
-                                   const variant<Ts...> &rhs) {
-    using mpark_detail::visitation::variant;
-    using lib::less_equal;
-#ifdef MPARK_CPP14_CONSTEXPR
-    if (lhs.valueless_by_exception()) return true;
-    if (rhs.valueless_by_exception()) return false;
-    if (lhs.index() < rhs.index()) return true;
-    if (lhs.index() > rhs.index()) return false;
-    return variant::visit_value_at(lhs.index(), less_equal{}, lhs, rhs);
-#else
-    return lhs.valueless_by_exception() ||
-           (!rhs.valueless_by_exception() &&
-            (lhs.index() < rhs.index() ||
-             (lhs.index() == rhs.index() &&
-              variant::visit_value_at(lhs.index(), less_equal{}, lhs, rhs))));
-#endif
-  }
-
-  template <typename... Ts>
-  inline constexpr bool operator>=(const variant<Ts...> &lhs,
-                                   const variant<Ts...> &rhs) {
-    using mpark_detail::visitation::variant;
-    using lib::greater_equal;
-#ifdef MPARK_CPP14_CONSTEXPR
-    if (rhs.valueless_by_exception()) return true;
-    if (lhs.valueless_by_exception()) return false;
-    if (lhs.index() > rhs.index()) return true;
-    if (lhs.index() < rhs.index()) return false;
-    return variant::visit_value_at(lhs.index(), greater_equal{}, lhs, rhs);
-#else
-    return rhs.valueless_by_exception() ||
-           (!lhs.valueless_by_exception() &&
-            (lhs.index() > rhs.index() ||
-             (lhs.index() == rhs.index() &&
-              variant::visit_value_at(
-                  lhs.index(), greater_equal{}, lhs, rhs))));
-#endif
-  }
-
-  struct monostate {};
-
-  inline constexpr bool operator<(monostate, monostate) noexcept {
-    return false;
-  }
-
-  inline constexpr bool operator>(monostate, monostate) noexcept {
-    return false;
-  }
-
-  inline constexpr bool operator<=(monostate, monostate) noexcept {
-    return true;
-  }
-
-  inline constexpr bool operator>=(monostate, monostate) noexcept {
-    return true;
-  }
-
-  inline constexpr bool operator==(monostate, monostate) noexcept {
-    return true;
-  }
-
-  inline constexpr bool operator!=(monostate, monostate) noexcept {
-    return false;
-  }
-
-#ifdef MPARK_CPP14_CONSTEXPR
-  namespace mpark_detail {
-
-    inline constexpr bool all(std::initializer_list<bool> bs) {
-      for (bool b : bs) {
-        if (!b) {
-          return false;
-        }
-      }
-      return true;
-    }
-
-  }  // namespace mpark_detail
-
-  template <typename Visitor, typename... Vs>
-  inline constexpr decltype(auto) visit(Visitor &&visitor, Vs &&... vs) {
-    return (mpark_detail::all({!vs.valueless_by_exception()...})
-                ? (void)0
-                : throw_bad_variant_access()),
-           mpark_detail::visitation::variant::visit_value(
-               lib::forward<Visitor>(visitor), lib::forward<Vs>(vs)...);
-  }
-#else
-  namespace mpark_detail {
-
-    template <std::size_t N>
-    inline constexpr bool all_impl(const lib::array<bool, N> &bs,
-                                   std::size_t idx) {
-      return idx >= N || (bs[idx] && all_impl(bs, idx + 1));
-    }
-
-    template <std::size_t N>
-    inline constexpr bool all(const lib::array<bool, N> &bs) {
-      return all_impl(bs, 0);
-    }
-
-  }  // namespace mpark_detail
-
-  template <typename Visitor, typename... Vs>
-  inline constexpr DECLTYPE_AUTO visit(Visitor &&visitor, Vs &&... vs)
-    DECLTYPE_AUTO_RETURN(
-        (mpark_detail::all(
-             lib::array<bool, sizeof...(Vs)>{{!vs.valueless_by_exception()...}})
-             ? (void)0
-             : throw_bad_variant_access()),
-        mpark_detail::visitation::variant::visit_value(lib::forward<Visitor>(visitor),
-                                                 lib::forward<Vs>(vs)...))
-#endif
-
-#if defined(__GNUC__) && !defined(__clang__)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wnoexcept"
-#endif
-  template <typename... Ts>
-  inline auto swap(variant<Ts...> &lhs,
-                   variant<Ts...> &rhs) noexcept(noexcept(lhs.swap(rhs)))
-      -> decltype(lhs.swap(rhs)) {
-    lhs.swap(rhs);
-  }
-#if defined(__GNUC__) && !defined(__clang__)
-#pragma GCC diagnostic pop
-#endif
-
-  namespace mpark_detail {
-
-    template <typename T, typename...>
-    using enabled_type = T;
-
-    namespace hash {
-
-      template <typename H, typename K>
-      constexpr bool meets_requirements() noexcept {
-        return std::is_copy_constructible<H>::value &&
-               std::is_move_constructible<H>::value &&
-               lib::is_invocable_r<std::size_t, H, const K &>::value;
-      }
-
-      template <typename K>
-      constexpr bool is_enabled() noexcept {
-        using H = std::hash<K>;
-        return meets_requirements<H, K>() &&
-               std::is_default_constructible<H>::value &&
-               std::is_copy_assignable<H>::value &&
-               std::is_move_assignable<H>::value;
-      }
-
-    }  // namespace hash
-
-  }  // namespace mpark_detail
-
-#undef AUTO
-#undef AUTO_RETURN
-
-#undef AUTO_REFREF
-#undef AUTO_REFREF_RETURN
-
-#undef DECLTYPE_AUTO
-#undef DECLTYPE_AUTO_RETURN
-
-} // namespace vital- mpark
-} // namespace kwiver
-namespace std {
-
-  template <typename... Ts>
-  struct hash<mpark::mpark_detail::enabled_type<
-      mpark::variant<Ts...>,
-      mpark::lib::enable_if_t<mpark::lib::all<mpark::mpark_detail::hash::is_enabled<
-          mpark::lib::remove_const_t<Ts>>()...>::value>>> {
-    using argument_type = mpark::variant<Ts...>;
-    using result_type = std::size_t;
-
-    inline result_type operator()(const argument_type &v) const {
-      using mpark::mpark_detail::visitation::variant;
-      std::size_t result =
-          v.valueless_by_exception()
-              ? 299792458  // Random value chosen by the universe upon creation
-              : variant::visit_alt(
-#ifdef MPARK_GENERIC_LAMBDAS
-                    [](const auto &alt) {
-                      using alt_type = mpark::lib::decay_t<decltype(alt)>;
-                      using value_type = mpark::lib::remove_const_t<
-                          typename alt_type::value_type>;
-                      return hash<value_type>{}(alt.value);
-                    }
-#else
-                    hasher{}
-#endif
-                    ,
-                    v);
-      return hash_combine(result, hash<std::size_t>{}(v.index()));
-    }
-
-    private:
-#ifndef MPARK_GENERIC_LAMBDAS
-    struct hasher {
-      template <typename Alt>
-      inline std::size_t operator()(const Alt &alt) const {
-        using alt_type = mpark::lib::decay_t<Alt>;
-        using value_type =
-            mpark::lib::remove_const_t<typename alt_type::value_type>;
-        return hash<value_type>{}(alt.value);
-      }
-    };
-#endif
-
-    static std::size_t hash_combine(std::size_t lhs, std::size_t rhs) {
-      return lhs ^= rhs + 0x9e3779b9 + (lhs << 6) + (lhs >> 2);
-    }
-  };
-
-  template <>
-  struct hash<mpark::monostate> {
-    using argument_type = mpark::monostate;
-    using result_type = std::size_t;
-
-    inline result_type operator()(const argument_type &) const noexcept {
-      return 66740831;  // return a fundamentally attractive random value.
-    }
-  };
-
-}  // namespace std
-
-#endif  // MPARK_VARIANT_HPP
diff --git a/vital/util/visit.h b/vital/util/visit.h
index e124930b03..805f4fba70 100644
--- a/vital/util/visit.h
+++ b/vital/util/visit.h
@@ -8,8 +8,6 @@
 #ifndef KWIVER_VITAL_UTIL_VISIT_H_
 #define KWIVER_VITAL_UTIL_VISIT_H_
 
-// TODO(C++17): replace with std::variant
-#include <vital/util/variant/variant.hpp>
 #include <vital/vital_config.h>
 #include <vital/util/demangle.h>
 #include <vital/exceptions.h>
@@ -17,6 +15,7 @@
 #include <map>
 #include <stdexcept>
 #include <typeindex>
+#include <variant>
 
 namespace kwiver {
 
@@ -76,7 +75,7 @@ invoke_visitor_return( Visitor&& visitor )
 template < class Visitor, class... Types >
 void
 visit_variant_types( Visitor&& visitor, std::type_info const& type,
-                     VITAL_UNUSED variant< Types... > const* )
+                     VITAL_UNUSED std::variant< Types... > const* )
 {
   return visit_types< Visitor, Types... >(
     std::forward< Visitor >( visitor ), type );
@@ -86,7 +85,7 @@ visit_variant_types( Visitor&& visitor, std::type_info const& type,
 template < class ReturnT, class Visitor, class... Types >
 ReturnT
 visit_variant_types_return( Visitor&& visitor, std::type_info const& type,
-                            VITAL_UNUSED variant< Types... > const* )
+                            VITAL_UNUSED std::variant< Types... > const* )
 {
   return visit_types_return< ReturnT, Visitor, Types... >(
     std::forward< Visitor >( visitor ), type );


Test patch:
diff --git a/sprokit/tests/sprokit/pipeline_util/test_load_pipe.cxx b/sprokit/tests/sprokit/pipeline_util/test_load_pipe.cxx
index 508486c292..b2bc9a624f 100644
--- a/sprokit/tests/sprokit/pipeline_util/test_load_pipe.cxx
+++ b/sprokit/tests/sprokit/pipeline_util/test_load_pipe.cxx
@@ -98,7 +98,7 @@ IMPLEMENT_TEST(empty)
 
   test_visitor v;
 
-  for ( auto b : blocks ) { kwiver::vital::visit( v, b ); }
+  for ( auto b : blocks ) { std::visit( v, b ); }
 
   v.expect(0, 0, 0, 0);
 }
@@ -110,7 +110,7 @@ IMPLEMENT_TEST(comments)
 
   test_visitor v;
 
-  for ( auto b : blocks ) { kwiver::vital::visit( v, b ); }
+  for ( auto b : blocks ) { std::visit( v, b ); }
 
   v.expect(0, 0, 0, 0);
 }
@@ -122,7 +122,7 @@ IMPLEMENT_TEST(empty_config)
 
   test_visitor v;
 
-  for ( auto b : blocks ) { kwiver::vital::visit( v, b ); }
+  for ( auto b : blocks ) { std::visit( v, b ); }
 
   v.expect(1, 0, 0, 0);
 }
@@ -134,7 +134,7 @@ IMPLEMENT_TEST(config_block)
 
   test_visitor v;
 
-  for ( auto b : blocks ) { kwiver::vital::visit( v, b ); }
+  for ( auto b : blocks ) { std::visit( v, b ); }
 
   v.expect(1, 0, 0, 0);
 }
@@ -146,7 +146,7 @@ IMPLEMENT_TEST(config_block_block)
 
   test_visitor v;
 
-  for ( auto b : blocks ) { kwiver::vital::visit( v, b ); }
+  for ( auto b : blocks ) { std::visit( v, b ); }
 
   v.expect(1, 0, 0, 0);
 }
@@ -158,7 +158,7 @@ IMPLEMENT_TEST(config_block_relativepath)
 
   test_visitor v;
 
-  for ( auto b : blocks ) { kwiver::vital::visit( v, b ); }
+  for ( auto b : blocks ) { std::visit( v, b ); }
 
   v.expect(1, 0, 0, 0);
 }
@@ -170,7 +170,7 @@ IMPLEMENT_TEST(config_block_long_block)
 
   test_visitor v;
 
-  for ( auto b : blocks ) { kwiver::vital::visit( v, b ); }
+  for ( auto b : blocks ) { std::visit( v, b ); }
 
   v.expect(1, 0, 0, 0);
 }
@@ -182,7 +182,7 @@ IMPLEMENT_TEST(config_block_nested_block)
 
   test_visitor v;
 
-  for ( auto b : blocks ) { kwiver::vital::visit( v, b ); }
+  for ( auto b : blocks ) { std::visit( v, b ); }
 
   v.expect(1, 0, 0, 0);
 }
@@ -210,7 +210,7 @@ IMPLEMENT_TEST(config_block_notalnum)
 
   test_visitor v;
 
-  for ( auto b : blocks ) { kwiver::vital::visit( v, b ); }
+  for ( auto b : blocks ) { std::visit( v, b ); }
 
   v.expect(2, 0, 0, 0);
 }
@@ -222,7 +222,7 @@ IMPLEMENT_TEST(config_value_spaces)
 
   test_visitor v;
 
-  for ( auto b : blocks ) { kwiver::vital::visit( v, b ); }
+  for ( auto b : blocks ) { std::visit( v, b ); }
 
   v.expect(1, 0, 0, 0);
 }
@@ -234,7 +234,7 @@ IMPLEMENT_TEST(one_process)
 
   test_visitor v;
 
-  for ( auto b : blocks ) { kwiver::vital::visit( v, b ); }
+  for ( auto b : blocks ) { std::visit( v, b ); }
 
   v.expect(0, 1, 0, 0);
 }
@@ -246,7 +246,7 @@ IMPLEMENT_TEST(connected_processes)
 
   test_visitor v;
 
-  for ( auto b : blocks ) { kwiver::vital::visit( v, b ); }
+  for ( auto b : blocks ) { std::visit( v, b ); }
 
   v.expect(0, 2, 1, 0);
 }
@@ -258,7 +258,7 @@ IMPLEMENT_TEST(connected_processes_notalnum)
 
   test_visitor v;
 
-  for ( auto b : blocks ) { kwiver::vital::visit( v, b ); }
+  for ( auto b : blocks ) { std::visit( v, b ); }
 
   v.expect(0, 2, 3, 0);
 }
@@ -270,7 +270,7 @@ IMPLEMENT_TEST(include)
 
   test_visitor v;
 
-  for ( auto b : blocks ) { kwiver::vital::visit( v, b ); }
+  for ( auto b : blocks ) { std::visit( v, b ); }
 
   v.expect(1, 0, 0, 0);
 }
@@ -285,7 +285,7 @@ IMPLEMENT_TEST(include_env)
 
   test_visitor v;
 
-  for ( auto b : blocks ) { kwiver::vital::visit( v, b ); }
+  for ( auto b : blocks ) { std::visit( v, b ); }
 
   v.expect(1, 0, 0, 0);
 }
@@ -338,7 +338,7 @@ IMPLEMENT_TEST(envvar)
 
   test_visitor v;
 
-  for ( auto b : blocks ) { kwiver::vital::visit( v, b ); }
+  for ( auto b : blocks ) { std::visit( v, b ); }
 
   v.expect(0, 0, 0, 0);
 }
@@ -350,7 +350,7 @@ IMPLEMENT_TEST(cluster_declare)
 
   test_visitor v;
 
-  for ( auto b : blocks ) { kwiver::vital::visit( v, b ); }
+  for ( auto b : blocks ) { std::visit( v, b ); }
 
   v.expect(0, 0, 0, 1);
 }
@@ -362,7 +362,7 @@ IMPLEMENT_TEST(cluster_config)
 
   test_visitor v;
 
-  for ( auto b : blocks ) { kwiver::vital::visit( v, b ); }
+  for ( auto b : blocks ) { std::visit( v, b ); }
 
   v.expect(0, 0, 0, 1);
 }
@@ -374,7 +374,7 @@ IMPLEMENT_TEST(cluster_input_map)
 
   test_visitor v;
 
-  for ( auto b : blocks ) { kwiver::vital::visit( v, b ); }
+  for ( auto b : blocks ) { std::visit( v, b ); }
 
   v.expect(0, 0, 0, 1);
 }
@@ -386,7 +386,7 @@ IMPLEMENT_TEST(cluster_input_multi_map)
 
   test_visitor v;
 
-  for ( auto b : blocks ) { kwiver::vital::visit( v, b ); }
+  for ( auto b : blocks ) { std::visit( v, b ); }
 
   v.expect(0, 0, 0, 1);
 }
@@ -398,7 +398,7 @@ IMPLEMENT_TEST(cluster_output_map)
 
   test_visitor v;
 
-  for ( auto b : blocks ) { kwiver::vital::visit( v, b ); }
+  for ( auto b : blocks ) { std::visit( v, b ); }
 
   v.expect(0, 0, 0, 1);
 }
@@ -410,7 +410,7 @@ IMPLEMENT_TEST(cluster_mappings)
 
   test_visitor v;
 
-  for ( auto b : blocks ) { kwiver::vital::visit( v, b ); }
+  for ( auto b : blocks ) { std::visit( v, b ); }
 
   v.expect(0, 0, 0, 1);
 }
@@ -422,7 +422,7 @@ IMPLEMENT_TEST(cluster_all)
 
   test_visitor v;
 
-  for ( auto b : blocks ) { kwiver::vital::visit( v, b ); }
+  for ( auto b : blocks ) { std::visit( v, b ); }
 
   v.expect(0, 0, 0, 1);
 }
@@ -498,7 +498,7 @@ IMPLEMENT_TEST(cluster_input_map_with_slash)
 
   test_visitor v;
 
-  for ( auto b : blocks ) { kwiver::vital::visit( v, b ); }
+  for ( auto b : blocks ) { std::visit( v, b ); }
 
   v.expect(0, 0, 0, 1);
 }
@@ -510,7 +510,7 @@ IMPLEMENT_TEST(cluster_output_map_with_slash)
 
   test_visitor v;
 
-  for ( auto b : blocks ) { kwiver::vital::visit( v, b ); }
+  for ( auto b : blocks ) { std::visit( v, b ); }
 
   v.expect(0, 0, 0, 1);
 }
@@ -530,7 +530,7 @@ IMPLEMENT_TEST(connect_input_with_slash)
 
   test_visitor v;
 
-  for ( auto b : blocks ) { kwiver::vital::visit( v, b ); }
+  for ( auto b : blocks ) { std::visit( v, b ); }
 
   v.expect(0, 0, 1, 0);
 }
@@ -542,7 +542,7 @@ IMPLEMENT_TEST(connect_output_with_slash)
 
   test_visitor v;
 
-  for ( auto b : blocks ) { kwiver::vital::visit( v, b ); }
+  for ( auto b : blocks ) { std::visit( v, b ); }
 
   v.expect(0, 0, 1, 0);
 }
diff --git a/vital/util/tests/test_visit.cxx b/vital/util/tests/test_visit.cxx
index 054a751950..2388207bb1 100644
--- a/vital/util/tests/test_visit.cxx
+++ b/vital/util/tests/test_visit.cxx
@@ -95,7 +95,7 @@ TEST ( visit, visit_types_return )
   }
 }
 
-using variant_t = variant< int, char >;
+using variant_t = std::variant< int, char >;
 
 // ----------------------------------------------------------------------------
 TEST ( visit, visit_variant_types )