From 70f6220fa32b693be76feecabafe4e5b9a679762 Mon Sep 17 00:00:00 2001
From: Kenneth Moreland <kmorel@sandia.gov>
Date: Wed, 4 Dec 2019 07:30:47 -0700
Subject: [PATCH] Add vtkm::List

`vtkm::List` is meant to replace `vtkm::ListTag`. Rather than
subclassing a base class with a variadic template, all lists expose the
list of types.

`vtkm::ListTag` was originally created before we required C++11 so
supporting variadic templates was problematic. To hide the issue we had,
we made list tags subclass other lists rather than be the list
themselves. It makes for nicer types in the compiler, but hides
important details about what is actually in the type. It also creates
lots of unnecessary new types.

The new `vtkm::List` is in some ways simpler. All lists have to be a
`vtkm::List`. Subclasses are not supported (or rather, they will not
work as expected). All manipulations (such as `vtkm::ListAppend`)
resolve directly back to a `vtkm::List`. Although the types reported by
the compiler will be longer, they will be more specific to the types
being used. Also, the new implimentation should ultimately use fewer
types.
---
 vtkm/CMakeLists.txt           |   1 +
 vtkm/List.h                   | 422 ++++++++++++++++++++++++++++++++++
 vtkm/ListTag.h                |  73 +++---
 vtkm/internal/ListTagDetail.h |  24 --
 vtkm/testing/CMakeLists.txt   |   1 +
 vtkm/testing/Testing.h        |  29 +++
 vtkm/testing/UnitTestList.cxx | 257 +++++++++++++++++++++
 7 files changed, 738 insertions(+), 69 deletions(-)
 create mode 100644 vtkm/List.h
 create mode 100644 vtkm/testing/UnitTestList.cxx

diff --git a/vtkm/CMakeLists.txt b/vtkm/CMakeLists.txt
index 22986574e..2155d0c33 100644
--- a/vtkm/CMakeLists.txt
+++ b/vtkm/CMakeLists.txt
@@ -30,6 +30,7 @@ set(headers
   Geometry.h
   Hash.h
   ImplicitFunction.h
+  List.h
   ListTag.h
   Math.h
   Matrix.h
diff --git a/vtkm/List.h b/vtkm/List.h
new file mode 100644
index 000000000..7b398591b
--- /dev/null
+++ b/vtkm/List.h
@@ -0,0 +1,422 @@
+//============================================================================
+//  Copyright (c) Kitware, Inc.
+//  All rights reserved.
+//  See LICENSE.txt for details.
+//
+//  This software is distributed WITHOUT ANY WARRANTY; without even
+//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+//  PURPOSE.  See the above copyright notice for more information.
+//============================================================================
+#ifndef vtk_m_List_h
+#define vtk_m_List_h
+
+#include <vtkm/Types.h>
+
+#include <vtkm/internal/brigand.hpp>
+
+namespace vtkm
+{
+
+template <typename... Ts>
+struct List
+{
+};
+
+namespace internal
+{
+
+template <typename T>
+struct IsListImpl
+{
+  using type = std::false_type;
+};
+
+template <typename... Ts>
+struct IsListImpl<vtkm::List<Ts...>>
+{
+  using type = std::true_type;
+};
+
+template <typename T>
+using IsList = typename vtkm::internal::IsListImpl<T>::type;
+
+} // namespace internal
+
+/// Checks that the argument is a proper list. This is a handy concept
+/// check for functions and classes to make sure that a template argument is
+/// actually a device adapter tag. (You can get weird errors elsewhere in the
+/// code when a mistake is made.)
+///
+#define VTKM_IS_LIST(type)                                                                         \
+  VTKM_STATIC_ASSERT_MSG((::vtkm::internal::IsList<type>::value),                                  \
+                         "Provided type is not a valid VTK-m list type.")
+
+namespace detail
+{
+
+/// list value that is used to represent a list actually matches all values
+struct UniversalTypeTag
+{
+  //We never want this tag constructed, and by deleting the constructor
+  //we get an error when trying to use this class with ForEach.
+  UniversalTypeTag() = delete;
+};
+
+} // namespace detail
+
+namespace internal
+{
+
+// This is here so that the old (deprecated) `ListTag`s can convert themselves to the new
+// `List` style and be operated on. When that deprecated functionality goes away, we can
+// probably remove `AsList` and just operate directly on the `List`s.
+template <typename T>
+struct AsListImpl;
+
+template <typename... Ts>
+struct AsListImpl<vtkm::List<Ts...>>
+{
+  using type = vtkm::List<Ts...>;
+};
+
+template <typename T>
+using AsList = typename AsListImpl<T>::type;
+}
+
+/// A special tag for an empty list.
+///
+using ListEmpty = vtkm::List<>;
+
+/// A special tag for a list that represents holding all potential values
+///
+/// Note: Can not be used with ForEach and some list transforms for obvious reasons.
+using ListUniversal = vtkm::List<detail::UniversalTypeTag>;
+
+namespace detail
+{
+
+template <typename T, template <typename...> class Target>
+struct ListApplyImpl;
+template <typename... Ts, template <typename...> class Target>
+struct ListApplyImpl<vtkm::List<Ts...>, Target>
+{
+  using type = Target<Ts...>;
+};
+// Cannot apply the universal list.
+template <template <typename...> class Target>
+struct ListApplyImpl<vtkm::ListUniversal, Target>;
+
+} // namespace detail
+
+/// \brief Applies the list of types to a template.
+///
+/// Given a ListTag and a templated class, returns the class instantiated with the types
+/// represented by the ListTag.
+///
+template <typename List, template <typename...> class Target>
+using ListApply = typename detail::ListApplyImpl<internal::AsList<List>, Target>::type;
+
+/// Becomes an std::integral_constant containing the number of types in a list.
+///
+template <typename List>
+using ListSize =
+  std::integral_constant<vtkm::IdComponent,
+                         vtkm::IdComponent{ brigand::size<internal::AsList<List>>::value }>;
+
+/// \brief Finds the type at the given index.
+///
+/// This becomes the type of the list at the given index.
+///
+template <typename List, vtkm::IdComponent Index>
+using ListAt =
+  brigand::at<internal::AsList<List>, std::integral_constant<vtkm::IdComponent, Index>>;
+
+namespace detail
+{
+
+// This find is roughly based on the brigand::find functionality. We don't use brigand::find
+// because it has an apparent bug where if a list contains templated types, it trys to
+// apply those types as predicates, which is wrong.
+
+template <vtkm::IdComponent NumSearched, typename Target, typename... Remaining>
+struct FindFirstOfType;
+
+// Not found;
+template <vtkm::IdComponent NumSearched, typename Target>
+struct FindFirstOfType<NumSearched, Target> : std::integral_constant<vtkm::IdComponent, -1>
+{
+};
+
+// Basic search next one
+template <vtkm::IdComponent NumSearched, typename Target, typename Next, typename... Remaining>
+struct FindFirstOfType<NumSearched, Target, Next, Remaining...>
+  : std::conditional<std::is_same<Target, Next>::value,
+                     std::integral_constant<vtkm::IdComponent, NumSearched>,
+                     FindFirstOfType<NumSearched + 1, Target, Remaining...>>::type
+{
+};
+
+// If there are at least 6 entries, check the first 4 to quickly narrow down
+template <vtkm::IdComponent NumSearched,
+          typename Target,
+          typename T0,
+          typename T1,
+          typename T2,
+          typename T3,
+          typename T4,
+          typename T5,
+          typename... Ts>
+struct FindFirstOfType<NumSearched, Target, T0, T1, T2, T3, T3, T4, T5, Ts...>
+  : std::conditional<(std::is_same<Target, T0>::value || std::is_same<Target, T1>::value ||
+                      std::is_same<Target, T2>::value ||
+                      std::is_same<Target, T3>::value),
+                     FindFirstOfType<NumSearched, Target, T0, T1, T2, T3>,
+                     FindFirstOfType<NumSearched + 4, Target, T4, T5, Ts...>>::type
+{
+};
+
+// If there are at least 12 entries, check the first 8 to quickly narrow down
+template <vtkm::IdComponent NumSearched,
+          typename Target,
+          typename T0,
+          typename T1,
+          typename T2,
+          typename T3,
+          typename T4,
+          typename T5,
+          typename T6,
+          typename T7,
+          typename T8,
+          typename T9,
+          typename T10,
+          typename T11,
+          typename... Ts>
+struct FindFirstOfType<NumSearched,
+                       Target,
+                       T0,
+                       T1,
+                       T2,
+                       T3,
+                       T3,
+                       T4,
+                       T5,
+                       T6,
+                       T7,
+                       T8,
+                       T9,
+                       T10,
+                       T11,
+                       Ts...>
+  : std::conditional<(std::is_same<Target, T0>::value || std::is_same<Target, T1>::value ||
+                      std::is_same<Target, T2>::value ||
+                      std::is_same<Target, T3>::value ||
+                      std::is_same<Target, T4>::value ||
+                      std::is_same<Target, T5>::value ||
+                      std::is_same<Target, T6>::value ||
+                      std::is_same<Target, T7>::value),
+                     FindFirstOfType<NumSearched, Target, T0, T1, T2, T3, T4, T5, T6, T7>,
+                     FindFirstOfType<NumSearched + 4, Target, T8, T9, T10, T11, Ts...>>::type
+{
+};
+
+template <typename List, typename Target>
+struct ListIndexOfImpl;
+template <typename... Ts, typename Target>
+struct ListIndexOfImpl<vtkm::List<Ts...>, Target>
+{
+  using type = std::integral_constant<vtkm::IdComponent, FindFirstOfType<0, Target, Ts...>::value>;
+};
+template <typename Target>
+struct ListIndexOfImpl<vtkm::ListUniversal, Target>
+{
+  VTKM_STATIC_ASSERT_MSG((std::is_same<Target, void>::value && std::is_same<Target, int>::value),
+                         "Cannot get indices in a universal list.");
+};
+
+} // namespace detail
+
+/// \brief Finds the index of a given type.
+///
+/// Becomes a `std::integral_constant` for the index of the given type. If the
+/// given type is not in the list, the value is set to -1.
+///
+template <typename List, typename T>
+using ListIndexOf = typename detail::ListIndexOfImpl<internal::AsList<List>, T>::type;
+
+/// \brief Checks to see if the given `T` is in the list pointed to by `List`.
+///
+/// Becomes `std::true_type` if the `T` is in `List`. `std::false_type` otherwise.
+///
+template <typename List, typename T>
+using ListHas = std::integral_constant<bool, (vtkm::ListIndexOf<List, T>::value >= 0)>;
+
+/// Concatinates a set of lists into a single list.
+///
+/// Note that this does not work correctly with `vtkm::ListUniversal`.
+template <typename... Lists>
+using ListAppend = brigand::append<internal::AsList<Lists>...>;
+
+namespace detail
+{
+
+template <class State, class Element, class List>
+struct ListIntersectTags
+{
+  using has_u = vtkm::ListHas<List, Element>;
+  using type =
+    typename std::conditional<has_u::value, brigand::push_back<State, Element>, State>::type;
+};
+
+template <typename List1, typename List2>
+struct ListIntersectImpl
+{
+  VTKM_IS_LIST(List1);
+  VTKM_IS_LIST(List2);
+
+  using type =
+    brigand::fold<List1,
+                  vtkm::List<>,
+                  ListIntersectTags<brigand::_state, brigand::_element, brigand::pin<List2>>>;
+};
+
+template <typename List1>
+struct ListIntersectImpl<List1, vtkm::ListUniversal>
+{
+  VTKM_IS_LIST(List1);
+
+  using type = List1;
+};
+template <typename List2>
+struct ListIntersectImpl<vtkm::ListUniversal, List2>
+{
+  VTKM_IS_LIST(List2);
+
+  using type = List2;
+};
+template <>
+struct ListIntersectImpl<vtkm::ListUniversal, vtkm::ListUniversal>
+{
+  using type = vtkm::ListUniversal;
+};
+
+} // namespace detail
+
+/// Constructs a list containing types present in all lists.
+///
+template <typename List1, typename List2>
+using ListIntersect =
+  typename detail::ListIntersectImpl<internal::AsList<List1>, internal::AsList<List2>>::type;
+
+namespace detail
+{
+
+template <typename T, template <typename> class Target>
+struct ListTransformImpl;
+template <typename... Ts, template <typename> class Target>
+struct ListTransformImpl<vtkm::List<Ts...>, Target>
+{
+  using type = vtkm::List<Target<Ts>...>;
+};
+// Cannot transform the universal list.
+template <template <typename> class Target>
+struct ListTransformImpl<vtkm::ListUniversal, Target>;
+
+} // namespace detail
+
+/// Constructs a list containing all types in a source list applied to a transform template.
+///
+template <typename List, template <typename> class Transform>
+using ListTransform = typename detail::ListTransformImpl<internal::AsList<List>, Transform>::type;
+
+/// Takes an existing `List` and a predicate template that is applied to each type in the `List`.
+/// Any type in the `List` that has a value element equal to true (the equivalent of
+/// `std::true_type`), that item will be removed from the list. For example the following type
+///
+/// ```cpp
+/// vtkm::ListRemoveIf<vtkm::List<int, float, long long, double>, std::is_integral>
+/// ```
+///
+/// resolves to a `List` that is equivalent to `vtkm::List<float, double>` because
+/// `std::is_integral<int>` and `std::is_integral<long long>` resolve to `std::true_type` whereas
+/// `std::is_integral<float>` and `std::is_integral<double>` resolve to `std::false_type`.
+///
+template <typename List, template <typename> class Predicate>
+using ListRemoveIf =
+  brigand::remove_if<internal::AsList<List>, brigand::bind<Predicate, brigand::_1>>;
+
+namespace detail
+{
+
+// We want to use an initializer list as a trick to call a function once for each type, but
+// an initializer list needs a type, so create wrapper function that returns a value.
+template <typename Functor, typename... Args>
+VTKM_EXEC_CONT inline bool ListForEachCallThrough(Functor&& f, Args&&... args)
+{
+  f(std::forward<Args>(args)...);
+  return false; // Return value does not matter. Hopefully just thrown away.
+}
+
+template <typename Functor, typename... Ts, typename... Args>
+VTKM_EXEC_CONT void ListForEachImpl(Functor&& f, vtkm::List<Ts...>, Args&&... args)
+{
+  auto init_list = { ListForEachCallThrough(
+    std::forward<Functor>(f), Ts{}, std::forward<Args>(args)...)... };
+  (void)init_list;
+}
+
+template <typename Functor, typename... Args>
+VTKM_EXEC_CONT void ListForEachImpl(Functor&&, vtkm::ListEmpty, Args&&...)
+{
+  // No types to run functor on.
+}
+
+} // namespace detail
+
+/// For each typename represented by the list, call the functor with a
+/// default instance of that type.
+///
+template <typename Functor, typename List, typename... Args>
+VTKM_EXEC_CONT void ListForEach(Functor&& f, List, Args&&... args)
+{
+  detail::ListForEachImpl(
+    std::forward<Functor>(f), internal::AsList<List>{}, std::forward<Args>(args)...);
+}
+
+namespace detail
+{
+
+template <typename List1, typename List2>
+struct ListCrossImpl
+{
+  VTKM_IS_LIST(List1);
+  VTKM_IS_LIST(List2);
+
+  // This is a lazy Cartesian product generator.
+  // This version was settled on as being the best default
+  // version as all compilers including Intel handle this
+  // implementation without issue for very large cross products
+  using type = brigand::reverse_fold<
+    vtkm::List<List1, List2>,
+    vtkm::List<vtkm::List<>>,
+    brigand::lazy::join<brigand::lazy::transform<
+      brigand::_2,
+      brigand::defer<brigand::lazy::join<brigand::lazy::transform<
+        brigand::parent<brigand::_1>,
+        brigand::defer<brigand::bind<
+          vtkm::List,
+          brigand::lazy::push_front<brigand::_1, brigand::parent<brigand::_1>>>>>>>>>>;
+};
+
+} // namespace detail
+
+/// \brief Generates a list that is the cross product of two input lists.
+///
+/// The resulting list has the form of `vtkm::List<vtkm::List<A1,B1>, vtkm::List<A1,B2>,...>`
+///
+template <typename List1, typename List2>
+using ListCross =
+  typename detail::ListCrossImpl<internal::AsList<List1>, internal::AsList<List2>>::type;
+
+} // namespace vtkm
+
+#endif //vtk_m_List_h
diff --git a/vtkm/ListTag.h b/vtkm/ListTag.h
index 052143bb7..ce0d027d6 100644
--- a/vtkm/ListTag.h
+++ b/vtkm/ListTag.h
@@ -10,6 +10,8 @@
 #ifndef vtk_m_ListTag_h
 #define vtk_m_ListTag_h
 
+#include <vtkm/List.h>
+
 #include <vtkm/internal/ListTagDetail.h>
 
 #include <vtkm/StaticAssert.h>
@@ -20,6 +22,14 @@
 namespace vtkm
 {
 
+/// A special tag for a list that represents holding all potential values
+///
+/// Note: Can not be used with ForEach for obvious reasons.
+struct ListTagUniversal : detail::ListRoot
+{
+  using list = vtkm::detail::ListBase<vtkm::detail::UniversalTag>;
+};
+
 namespace internal
 {
 
@@ -60,6 +70,24 @@ struct ListTagAsBrigandListImpl
 template <typename ListTag>
 using ListTagAsBrigandList = typename detail::ListTagAsBrigandListImpl<ListTag>::type;
 
+template <typename List>
+using ListAsListTag = brigand::wrap<List, vtkm::ListTagBase>;
+
+// This allows the new `List` operations work on `ListTag`s.
+template <typename T>
+struct AsListImpl
+{
+  VTKM_STATIC_ASSERT_MSG(ListTagCheck<T>::value,
+                         "Attempted to use something that is not a List with a List operation.");
+  using type = brigand::wrap<ListTagAsBrigandList<T>, vtkm::List>;
+};
+
+template <>
+struct AsListImpl<vtkm::ListTagUniversal>
+{
+  using type = vtkm::ListUniversal;
+};
+
 } // namespace internal
 
 
@@ -86,14 +114,6 @@ template <typename ListTag, template <typename...> class Target>
 using ListTagApply =
   typename detail::ListTagApplyImpl<internal::ListTagAsBrigandList<ListTag>, Target>::type;
 
-/// A special tag for a list that represents holding all potential values
-///
-/// Note: Can not be used with ForEach for obvious reasons.
-struct ListTagUniversal : detail::ListRoot
-{
-  using list = vtkm::detail::ListBase<vtkm::detail::UniversalTag>;
-};
-
 /// A special tag for an empty list.
 ///
 struct ListTagEmpty : detail::ListRoot
@@ -171,30 +191,6 @@ struct ListTagRemoveIf : detail::ListRoot
                                   brigand::bind<Predicate, brigand::_1>>;
 };
 
-/// \brief Determines the number of types in the given list.
-///
-/// There is a static member named \c value that is set to the length of the list.
-///
-template <typename ListTag>
-struct ListSize
-{
-  VTKM_IS_LIST_TAG(ListTag);
-  static constexpr vtkm::IdComponent value =
-    detail::ListSizeImpl<internal::ListTagAsBrigandList<ListTag>>::value;
-};
-
-/// For each typename represented by the list tag, call the functor with a
-/// default instance of that type.
-///
-template <typename Functor, typename ListTag, typename... Args>
-VTKM_CONT void ListForEach(Functor&& f, ListTag, Args&&... args)
-{
-  VTKM_IS_LIST_TAG(ListTag);
-  detail::ListForEachImpl(std::forward<Functor>(f),
-                          internal::ListTagAsBrigandList<ListTag>{},
-                          std::forward<Args>(args)...);
-}
-
 /// Generate a tag that is the cross product of two other tags. The resulting
 /// tag has the form of Tag< brigand::list<A1,B1>, brigand::list<A1,B2> .... >
 ///
@@ -233,19 +229,6 @@ struct ListTypeAt
                            std::integral_constant<vtkm::IdComponent, Index>>;
 };
 
-/// \brief Finds the index of the given type.
-///
-/// There is a static member named \c value that is set to the index of the given type. If the
-/// given type is not in the list, the value is set to -1.
-///
-template <typename ListTag, typename Type>
-struct ListIndexOf
-{
-  VTKM_IS_LIST_TAG(ListTag);
-  static constexpr vtkm::IdComponent value =
-    detail::ListIndexOfImpl<Type, internal::ListTagAsBrigandList<ListTag>, 0>::value;
-};
-
 } // namespace vtkm
 
 #endif //vtk_m_ListTag_h
diff --git a/vtkm/internal/ListTagDetail.h b/vtkm/internal/ListTagDetail.h
index 8fe9c199c..befbfda6b 100644
--- a/vtkm/internal/ListTagDetail.h
+++ b/vtkm/internal/ListTagDetail.h
@@ -129,30 +129,6 @@ struct ListSizeImpl<brigand::list<Ts...>>
   static constexpr vtkm::IdComponent value = vtkm::IdComponent{ sizeof...(Ts) };
 };
 
-//-----------------------------------------------------------------------------
-template <typename Type, typename RemainingList, vtkm::IdComponent NumBefore>
-struct ListIndexOfImpl;
-
-template <typename Type, vtkm::IdComponent NumBefore>
-struct ListIndexOfImpl<Type, brigand::list<>, NumBefore>
-{
-  // Could not find index.
-  static constexpr vtkm::IdComponent value = -1;
-};
-
-template <typename Type, typename T1, typename... RemainingList, vtkm::IdComponent NumBefore>
-struct ListIndexOfImpl<Type, brigand::list<T1, RemainingList...>, NumBefore>
-{
-  static constexpr vtkm::IdComponent value =
-    ListIndexOfImpl<Type, brigand::list<RemainingList...>, NumBefore + 1>::value;
-};
-
-template <typename Type, typename... RemainingList, vtkm::IdComponent NumBefore>
-struct ListIndexOfImpl<Type, brigand::list<Type, RemainingList...>, NumBefore>
-{
-  static constexpr vtkm::IdComponent value = NumBefore;
-};
-
 //-----------------------------------------------------------------------------
 template <class T, class U, class ListTag>
 struct intersect_tags
diff --git a/vtkm/testing/CMakeLists.txt b/vtkm/testing/CMakeLists.txt
index 9fcee1795..8456c752e 100644
--- a/vtkm/testing/CMakeLists.txt
+++ b/vtkm/testing/CMakeLists.txt
@@ -25,6 +25,7 @@ set(unit_tests
   UnitTestDeprecated.cxx
   UnitTestExceptions.cxx
   UnitTestHash.cxx
+  UnitTestList.cxx
   UnitTestListTag.cxx
   UnitTestMath.cxx
   UnitTestMatrix.cxx
diff --git a/vtkm/testing/Testing.h b/vtkm/testing/Testing.h
index 50e1de6b9..0a05b226d 100644
--- a/vtkm/testing/Testing.h
+++ b/vtkm/testing/Testing.h
@@ -13,6 +13,7 @@
 #include <vtkm/Bitset.h>
 #include <vtkm/Bounds.h>
 #include <vtkm/CellShape.h>
+#include <vtkm/List.h>
 #include <vtkm/Math.h>
 #include <vtkm/Matrix.h>
 #include <vtkm/Pair.h>
@@ -150,6 +151,34 @@ struct TypeName<vtkm::Bitset<T>>
   }
 };
 
+template <typename T0, typename... Ts>
+struct TypeName<vtkm::List<T0, Ts...>>
+{
+  static std::string Name()
+  {
+    std::initializer_list<std::string> subtypeStrings = { TypeName<Ts>::Name()... };
+
+    std::stringstream stream;
+    stream << "vtkm::List<" << TypeName<T0>::Name();
+    for (auto&& subtype : subtypeStrings)
+    {
+      stream << ", " << subtype;
+    }
+    stream << ">";
+    return stream.str();
+  }
+};
+template <>
+struct TypeName<vtkm::ListEmpty>
+{
+  static std::string Name() { return "vtkm::ListEmpty"; }
+};
+template <>
+struct TypeName<vtkm::ListUniversal>
+{
+  static std::string Name() { return "vtkm::ListUniversal"; }
+};
+
 namespace detail
 {
 
diff --git a/vtkm/testing/UnitTestList.cxx b/vtkm/testing/UnitTestList.cxx
new file mode 100644
index 000000000..5561ac46d
--- /dev/null
+++ b/vtkm/testing/UnitTestList.cxx
@@ -0,0 +1,257 @@
+//============================================================================
+//  Copyright (c) Kitware, Inc.
+//  All rights reserved.
+//  See LICENSE.txt for details.
+//
+//  This software is distributed WITHOUT ANY WARRANTY; without even
+//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+//  PURPOSE.  See the above copyright notice for more information.
+//============================================================================
+
+#include <vtkm/List.h>
+
+#include <vtkm/testing/Testing.h>
+
+#include <vector>
+
+namespace
+{
+
+template <int N>
+struct TestClass
+{
+};
+
+} // anonymous namespace
+
+namespace vtkm
+{
+namespace testing
+{
+
+template <int N>
+struct TypeName<TestClass<N>>
+{
+  static std::string Name()
+  {
+    std::stringstream stream;
+    stream << "TestClass<" << N << ">";
+    return stream.str();
+  }
+};
+}
+} // namespace vtkm::testing
+
+namespace
+{
+
+template <typename T>
+struct DoubleTransformLazy;
+template <int N>
+struct DoubleTransformLazy<TestClass<N>>
+{
+  using type = TestClass<2 * N>;
+};
+
+template <typename T>
+using DoubleTransform = typename DoubleTransformLazy<T>::type;
+
+template <typename T>
+struct EvenPredicate;
+template <int N>
+struct EvenPredicate<TestClass<N>> : std::integral_constant<bool, (N % 2) == 0>
+{
+};
+
+template <typename T1, typename T2>
+void CheckSame(T1, T2)
+{
+  VTKM_STATIC_ASSERT((std::is_same<T1, T2>::value));
+
+  std::cout << "     Got expected type: " << vtkm::testing::TypeName<T1>::Name() << std::endl;
+}
+
+template <typename ExpectedList, typename List>
+void CheckList(ExpectedList, List)
+{
+  VTKM_IS_LIST(List);
+  CheckSame(ExpectedList{}, List{});
+}
+
+template <int N>
+int test_number(TestClass<N>)
+{
+  return N;
+}
+
+template <typename T>
+struct MutableFunctor
+{
+  std::vector<T> FoundTypes;
+
+  template <typename U>
+  VTKM_CONT void operator()(U u)
+  {
+    this->FoundTypes.push_back(test_number(u));
+  }
+};
+
+template <typename T>
+struct ConstantFunctor
+{
+  template <typename U, typename VectorType>
+  VTKM_CONT void operator()(U u, VectorType& vector) const
+  {
+    vector.push_back(test_number(u));
+  }
+};
+
+void TryForEach()
+{
+  using TestList =
+    vtkm::List<TestClass<1>, TestClass<1>, TestClass<2>, TestClass<3>, TestClass<5>, TestClass<8>>;
+  const std::vector<int> expectedList = { 1, 1, 2, 3, 5, 8 };
+
+  std::cout << "Check mutable for each" << std::endl;
+  MutableFunctor<int> functor;
+  vtkm::ListForEach(functor, TestList{});
+  VTKM_TEST_ASSERT(expectedList == functor.FoundTypes);
+
+  std::cout << "Check constant for each" << std::endl;
+  std::vector<int> foundTypes;
+  vtkm::ListForEach(ConstantFunctor<int>{}, TestList{}, foundTypes);
+  VTKM_TEST_ASSERT(expectedList == foundTypes);
+}
+
+void TestLists()
+{
+  using SimpleCount = vtkm::List<TestClass<1>, TestClass<2>, TestClass<3>, TestClass<4>>;
+  using EvenList = vtkm::List<TestClass<2>, TestClass<4>, TestClass<6>, TestClass<8>>;
+  using LongList = vtkm::List<TestClass<1>,
+                              TestClass<2>,
+                              TestClass<3>,
+                              TestClass<4>,
+                              TestClass<5>,
+                              TestClass<6>,
+                              TestClass<7>,
+                              TestClass<8>,
+                              TestClass<9>,
+                              TestClass<10>,
+                              TestClass<11>,
+                              TestClass<12>,
+                              TestClass<13>,
+                              TestClass<14>>;
+
+  TryForEach();
+
+  std::cout << "Valid List Tag Checks" << std::endl;
+  VTKM_TEST_ASSERT(vtkm::internal::IsList<vtkm::List<TestClass<11>>>::value);
+  VTKM_TEST_ASSERT(vtkm::internal::IsList<vtkm::List<TestClass<21>, TestClass<22>>>::value);
+  VTKM_TEST_ASSERT(vtkm::internal::IsList<vtkm::ListEmpty>::value);
+  VTKM_TEST_ASSERT(vtkm::internal::IsList<vtkm::ListUniversal>::value);
+
+  std::cout << "ListTagEmpty" << std::endl;
+  CheckList(vtkm::List<>{}, vtkm::ListEmpty{});
+
+  std::cout << "ListTagAppend" << std::endl;
+  CheckList(vtkm::List<TestClass<31>,
+                       TestClass<32>,
+                       TestClass<33>,
+                       TestClass<11>,
+                       TestClass<21>,
+                       TestClass<22>>{},
+            vtkm::ListAppend<vtkm::List<TestClass<31>, TestClass<32>, TestClass<33>>,
+                             vtkm::List<TestClass<11>>,
+                             vtkm::List<TestClass<21>, TestClass<22>>>{});
+
+  std::cout << "ListTagIntersect" << std::endl;
+  CheckList(vtkm::List<TestClass<3>, TestClass<5>>{},
+            vtkm::ListIntersect<
+              vtkm::List<TestClass<1>, TestClass<2>, TestClass<3>, TestClass<4>, TestClass<5>>,
+              vtkm::List<TestClass<3>, TestClass<5>, TestClass<6>>>{});
+  CheckList(vtkm::List<TestClass<1>, TestClass<2>>{},
+            vtkm::ListIntersect<vtkm::List<TestClass<1>, TestClass<2>>, vtkm::ListUniversal>{});
+  CheckList(vtkm::List<TestClass<1>, TestClass<2>>{},
+            vtkm::ListIntersect<vtkm::ListUniversal, vtkm::List<TestClass<1>, TestClass<2>>>{});
+
+  std::cout << "ListTransform" << std::endl;
+  CheckList(EvenList{}, vtkm::ListTransform<SimpleCount, DoubleTransform>{});
+
+  std::cout << "ListRemoveIf" << std::endl;
+  CheckList(vtkm::List<TestClass<1>, TestClass<3>>{},
+            vtkm::ListRemoveIf<SimpleCount, EvenPredicate>{});
+
+  std::cout << "ListSize" << std::endl;
+  VTKM_TEST_ASSERT(vtkm::ListSize<vtkm::ListEmpty>::value == 0);
+  VTKM_TEST_ASSERT(vtkm::ListSize<vtkm::List<TestClass<2>>>::value == 1);
+  VTKM_TEST_ASSERT(vtkm::ListSize<vtkm::List<TestClass<2>, TestClass<4>>>::value == 2);
+
+  std::cout << "ListCross" << std::endl;
+  CheckList(vtkm::List<vtkm::List<TestClass<31>, TestClass<11>>,
+                       vtkm::List<TestClass<32>, TestClass<11>>,
+                       vtkm::List<TestClass<33>, TestClass<11>>>{},
+            vtkm::ListCross<vtkm::List<TestClass<31>, TestClass<32>, TestClass<33>>,
+                            vtkm::List<TestClass<11>>>{});
+
+  std::cout << "ListAt" << std::endl;
+  CheckSame(TestClass<2>{}, vtkm::ListAt<EvenList, 0>{});
+  CheckSame(TestClass<4>{}, vtkm::ListAt<EvenList, 1>{});
+  CheckSame(TestClass<6>{}, vtkm::ListAt<EvenList, 2>{});
+  CheckSame(TestClass<8>{}, vtkm::ListAt<EvenList, 3>{});
+
+  std::cout << "ListIndexOf" << std::endl;
+  VTKM_TEST_ASSERT(vtkm::ListIndexOf<EvenList, TestClass<2>>::value == 0);
+  VTKM_TEST_ASSERT(vtkm::ListIndexOf<EvenList, TestClass<4>>::value == 1);
+  VTKM_TEST_ASSERT(vtkm::ListIndexOf<EvenList, TestClass<6>>::value == 2);
+  VTKM_TEST_ASSERT(vtkm::ListIndexOf<EvenList, TestClass<8>>::value == 3);
+  VTKM_TEST_ASSERT(vtkm::ListIndexOf<EvenList, TestClass<1>>::value == -1);
+
+  VTKM_TEST_ASSERT(vtkm::ListIndexOf<LongList, TestClass<1>>::value == 0);
+  VTKM_TEST_ASSERT(vtkm::ListIndexOf<LongList, TestClass<2>>::value == 1);
+  VTKM_TEST_ASSERT(vtkm::ListIndexOf<LongList, TestClass<3>>::value == 2);
+  VTKM_TEST_ASSERT(vtkm::ListIndexOf<LongList, TestClass<4>>::value == 3);
+  VTKM_TEST_ASSERT(vtkm::ListIndexOf<LongList, TestClass<5>>::value == 4);
+  VTKM_TEST_ASSERT(vtkm::ListIndexOf<LongList, TestClass<6>>::value == 5);
+  VTKM_TEST_ASSERT(vtkm::ListIndexOf<LongList, TestClass<7>>::value == 6);
+  VTKM_TEST_ASSERT(vtkm::ListIndexOf<LongList, TestClass<8>>::value == 7);
+  VTKM_TEST_ASSERT(vtkm::ListIndexOf<LongList, TestClass<9>>::value == 8);
+  VTKM_TEST_ASSERT(vtkm::ListIndexOf<LongList, TestClass<10>>::value == 9);
+  VTKM_TEST_ASSERT(vtkm::ListIndexOf<LongList, TestClass<11>>::value == 10);
+  VTKM_TEST_ASSERT(vtkm::ListIndexOf<LongList, TestClass<12>>::value == 11);
+  VTKM_TEST_ASSERT(vtkm::ListIndexOf<LongList, TestClass<13>>::value == 12);
+  VTKM_TEST_ASSERT(vtkm::ListIndexOf<LongList, TestClass<14>>::value == 13);
+  VTKM_TEST_ASSERT(vtkm::ListIndexOf<LongList, TestClass<15>>::value == -1);
+  VTKM_TEST_ASSERT(vtkm::ListIndexOf<LongList, TestClass<0>>::value == -1);
+
+  std::cout << "ListHas" << std::endl;
+  VTKM_TEST_ASSERT(vtkm::ListHas<EvenList, TestClass<2>>::value);
+  VTKM_TEST_ASSERT(vtkm::ListHas<EvenList, TestClass<4>>::value);
+  VTKM_TEST_ASSERT(vtkm::ListHas<EvenList, TestClass<6>>::value);
+  VTKM_TEST_ASSERT(vtkm::ListHas<EvenList, TestClass<8>>::value);
+  VTKM_TEST_ASSERT(!vtkm::ListHas<EvenList, TestClass<1>>::value);
+
+  VTKM_TEST_ASSERT(vtkm::ListHas<LongList, TestClass<1>>::value);
+  VTKM_TEST_ASSERT(vtkm::ListHas<LongList, TestClass<2>>::value);
+  VTKM_TEST_ASSERT(vtkm::ListHas<LongList, TestClass<3>>::value);
+  VTKM_TEST_ASSERT(vtkm::ListHas<LongList, TestClass<4>>::value);
+  VTKM_TEST_ASSERT(vtkm::ListHas<LongList, TestClass<5>>::value);
+  VTKM_TEST_ASSERT(vtkm::ListHas<LongList, TestClass<6>>::value);
+  VTKM_TEST_ASSERT(vtkm::ListHas<LongList, TestClass<7>>::value);
+  VTKM_TEST_ASSERT(vtkm::ListHas<LongList, TestClass<7>>::value);
+  VTKM_TEST_ASSERT(vtkm::ListHas<LongList, TestClass<8>>::value);
+  VTKM_TEST_ASSERT(vtkm::ListHas<LongList, TestClass<9>>::value);
+  VTKM_TEST_ASSERT(vtkm::ListHas<LongList, TestClass<10>>::value);
+  VTKM_TEST_ASSERT(vtkm::ListHas<LongList, TestClass<11>>::value);
+  VTKM_TEST_ASSERT(vtkm::ListHas<LongList, TestClass<12>>::value);
+  VTKM_TEST_ASSERT(vtkm::ListHas<LongList, TestClass<13>>::value);
+  VTKM_TEST_ASSERT(vtkm::ListHas<LongList, TestClass<14>>::value);
+  VTKM_TEST_ASSERT(!vtkm::ListHas<LongList, TestClass<15>>::value);
+  VTKM_TEST_ASSERT(!vtkm::ListHas<LongList, TestClass<0>>::value);
+}
+
+} // anonymous namespace
+
+int UnitTestList(int argc, char* argv[])
+{
+  return vtkm::testing::Testing::Run(TestLists, argc, argv);
+}