diff --git a/azure-pipelines.yml b/azure-pipelines.yml
index 91346af..a3d5aa9 100644
--- a/azure-pipelines.yml
+++ b/azure-pipelines.yml
@@ -5,11 +5,13 @@ jobs:
     steps:
       - checkout: self
         submodules: true
-      - script:
-          docker run -v${PWD}:/build
-            arbmind/qbs-clang7:1
-            build --file /build/BasiC++17.qbs --build-directory /tmp/build
-            -p autotest-runner
+      - task: ShellScript@2
+        inputs:
+          scriptPath: thirdparty/git_clone_googletest.sh
+      - script: docker run -v${PWD}:/build
+          arbmind/qbs-clang7:1
+          build --file /build/BasiC++17.qbs --build-directory /tmp/build
+          -p autotest-runner
 
   - job: Windows
     pool:
@@ -21,6 +23,9 @@ jobs:
       - script: qbs config --list profiles
       - checkout: self
         submodules: true
+      - task: ShellScript@2
+        inputs:
+          scriptPath: thirdparty/git_clone_googletest.sh
       - script: qbs
-            build profile:MSVC2019-x64 --file BasiC++17.qbs --build-directory %TMP%\build
-            -p autotest-runner
+          build profile:MSVC2019-x64 --file BasiC++17.qbs --build-directory %TMP%\build
+          -p autotest-runner
diff --git a/src/meta17.lib/meta17/IndexPack.extract.h b/src/meta17.lib/meta17/IndexPack.extract.h
index 04063d8..e4210c2 100644
--- a/src/meta17.lib/meta17/IndexPack.extract.h
+++ b/src/meta17.lib/meta17/IndexPack.extract.h
@@ -13,8 +13,8 @@ constexpr auto extract_index_pack = META17_STATIC_ERROR_EXPR(T, "no index_pack t
 template<template<size_t...> class Template, size_t... Is>
 constexpr auto extract_index_pack<Template<Is...>> = index_pack<Is...>;
 
-template<template<class, size_t...> class Template, size_t... Is>
-constexpr auto extract_index_pack<Template<size_t, Is...>> = index_pack<Is...>;
+template<template<class T, T...> class Template, class T, T... Is>
+constexpr auto extract_index_pack<Template<T, Is...>> = index_pack<Is...>;
 
 template<class T>
 using ExtractIndexPack = decltype(extract_index_pack<T>);
diff --git a/src/meta17.lib/meta17/IndexPack.iterate.h b/src/meta17.lib/meta17/IndexPack.iterate.h
new file mode 100644
index 0000000..b1a14ff
--- /dev/null
+++ b/src/meta17.lib/meta17/IndexPack.iterate.h
@@ -0,0 +1,13 @@
+#pragma once
+#include "Index.h"
+#include "IndexPack.h"
+
+namespace meta17 {
+
+/// "constexpr for": Iterate over a sequence with compile-time available indices
+template<class Callable, size_t... Is>
+constexpr auto forEachIndex(IndexPack<Is...>, Callable&& callable) {
+    return (..., callable(_index<Is>));
+}
+
+} // namespace meta17
diff --git a/src/meta17.lib/meta17/IndexPack.iterate.test.cpp b/src/meta17.lib/meta17/IndexPack.iterate.test.cpp
new file mode 100644
index 0000000..7f18a63
--- /dev/null
+++ b/src/meta17.lib/meta17/IndexPack.iterate.test.cpp
@@ -0,0 +1,11 @@
+#include "IndexPack.iterate.h"
+
+#include "Index.wrap.h" // UnwrapType
+#include <cinttypes>
+
+using namespace meta17;
+
+static_assert(forEachIndex(index_pack<12, 23>, [s = 0](auto i) mutable {
+                  s += to_value<decltype(i)>;
+                  return s;
+              }) == 35);
diff --git a/src/meta17.lib/meta17/TemplateOfTypes.indexOf.h b/src/meta17.lib/meta17/TemplateOfTypes.indexOf.h
index 4e379ab..61b1985 100644
--- a/src/meta17.lib/meta17/TemplateOfTypes.indexOf.h
+++ b/src/meta17.lib/meta17/TemplateOfTypes.indexOf.h
@@ -44,7 +44,7 @@ constexpr auto indexed_type_template_index_of = META17_STATIC_ERROR_EXPR(size_t,
 template<class T, template<typename...> class Template, class... Ts, size_t... Is>
 constexpr auto indexed_type_template_index_of<T, Template<Ts...>, IndexPack<Is...>> = //
     1 == countOf<T, Ts...>() ? (((type<Ts> == type<T>) ? Is : 0) + ...)
-                             : META17_STATIC_ERROR_EXPR(size_t, "type not found");
+                             : META17_STATIC_ASSERT_EXPR(size_t, (1 == countOf<T, Ts...>()), "type not found");
 
 template<class T, class TT>
 constexpr auto type_template_index_of = indexed_type_template_index_of<T, TT, IndexPackFor<TT>>;
diff --git a/src/meta17.lib/meta17/TemplateOfTypes.indexOf.test.cpp b/src/meta17.lib/meta17/TemplateOfTypes.indexOf.test.cpp
index d0c17be..496e5a7 100644
--- a/src/meta17.lib/meta17/TemplateOfTypes.indexOf.test.cpp
+++ b/src/meta17.lib/meta17/TemplateOfTypes.indexOf.test.cpp
@@ -12,3 +12,4 @@ static_assert(type_template_overflow_index_of<int, TypePack<char, int, unsigned>
 static_assert(type_template_overflow_index_of<int, TypePack<float, double>> == 2);
 
 static_assert(type_template_index_of<int, TypePack<void, char, int>> == 2);
+// static_assert(type_template_index_of<double, TypePack<void, char, int>> == 0);
diff --git a/src/meta17.lib/meta17/meta17.qbs b/src/meta17.lib/meta17/meta17.qbs
index 52b8909..c9d8221 100644
--- a/src/meta17.lib/meta17/meta17.qbs
+++ b/src/meta17.lib/meta17/meta17.qbs
@@ -1,6 +1,8 @@
 import qbs
 
 Product {
+    Depends { name: "cpp17" }
+
     Group {
         name: "Bool"
         files: [
@@ -48,6 +50,7 @@ Product {
             "IndexPack.extract.h",
             "IndexPack.for.h",
             "IndexPack.h",
+            "IndexPack.iterate.h",
             "IndexPack.make.h",
             "IndexPack.ops.h",
             "IndexPack.trait.h",
@@ -150,6 +153,7 @@ Product {
         "Unreachable.h",
         "align.h",
         "same.h",
+        "ptr.h",
     ]
 
     Export {
diff --git a/src/meta17.lib/meta17/meta17.tests.qbs b/src/meta17.lib/meta17/meta17.tests.qbs
index 3b198f8..c0da832 100644
--- a/src/meta17.lib/meta17/meta17.tests.qbs
+++ b/src/meta17.lib/meta17/meta17.tests.qbs
@@ -53,6 +53,7 @@ Application {
         files: [
             "IndexPack.extract.test.cpp",
             "IndexPack.for.test.cpp",
+            "IndexPack.iterate.test.cpp",
             "IndexPack.make.test.cpp",
             "IndexPack.ops.test.cpp",
             "IndexPack.test.cpp",
@@ -150,5 +151,6 @@ Application {
         "StaticErrorExpr.test.cpp",
         "align.test.cpp",
         "main.cpp",
+        "ptr.test.cpp",
     ]
 }
diff --git a/src/meta17.lib/meta17/ptr.h b/src/meta17.lib/meta17/ptr.h
new file mode 100644
index 0000000..fd42184
--- /dev/null
+++ b/src/meta17.lib/meta17/ptr.h
@@ -0,0 +1,8 @@
+#pragma once
+
+namespace meta17 {
+
+template<class T>
+constexpr T* nullptr_to = nullptr;
+
+}
diff --git a/src/meta17.lib/meta17/ptr.test.cpp b/src/meta17.lib/meta17/ptr.test.cpp
new file mode 100644
index 0000000..0a6dfb8
--- /dev/null
+++ b/src/meta17.lib/meta17/ptr.test.cpp
@@ -0,0 +1,7 @@
+#include "ptr.h"
+#include "same.h"
+
+using namespace meta17;
+
+static_assert(same<decltype(nullptr_to<int>), int* const>);
+static_assert(nullptr_to<int> == nullptr);
diff --git a/src/string17.lib/string17/StringView.ostream.h b/src/string17.lib/string17/StringView.ostream.h
index a2aeb46..fba6a98 100644
--- a/src/string17.lib/string17/StringView.ostream.h
+++ b/src/string17.lib/string17/StringView.ostream.h
@@ -5,7 +5,7 @@
 
 namespace string17 {
 
-auto operator<<(std::ostream& out, StringView v) -> std::ostream& {
+inline auto operator<<(std::ostream& out, StringView v) -> std::ostream& {
     return out.write(v.begin, v.size()); //
 }
 
diff --git a/src/strong17.lib/strong17/Strong.opaque.h b/src/strong17.lib/strong17/Strong.opaque.h
index 5156e44..e80f7de 100644
--- a/src/strong17.lib/strong17/Strong.opaque.h
+++ b/src/strong17.lib/strong17/Strong.opaque.h
@@ -4,8 +4,6 @@
 #include "Strong.make.h"
 
 #include "meta17/Type.h"
-#include "meta17/TypePack.h"
-#include "meta17/TypePack.recurse.h"
 
 #define STRONG_OPAQUE(NAME, TYPE, ...)                                                                                 \
     struct NAME;                                                                                                       \
diff --git a/src/strong17.lib/strong17/Strong.opaque.test.cpp b/src/strong17.lib/strong17/Strong.opaque.test.cpp
new file mode 100644
index 0000000..a45549e
--- /dev/null
+++ b/src/strong17.lib/strong17/Strong.opaque.test.cpp
@@ -0,0 +1,19 @@
+#include "Strong.opaque.h"
+
+#include <gtest/gtest.h>
+
+namespace testing {
+
+STRONG_OPAQUE(HelloTest, int, struct HelloTag);
+
+} // namespace testing
+
+STRONG_OPAQUE(HelloGlobal, int, struct HelloTag);
+
+TEST(Strong, opaque) {
+    constexpr auto ht = testing::HelloTest{15};
+    static_assert(ht.v == 15);
+
+    constexpr auto hg = HelloGlobal{23};
+    static_assert(hg.v == 23);
+}
diff --git a/src/strong17.lib/strong17/Strong.trait.h b/src/strong17.lib/strong17/Strong.trait.h
index 26bfe1a..e297591 100644
--- a/src/strong17.lib/strong17/Strong.trait.h
+++ b/src/strong17.lib/strong17/Strong.trait.h
@@ -12,14 +12,11 @@ using meta17::False;
 using meta17::is_type_template;
 using meta17::same;
 
-template<class, class = void>
-struct IsStrong : False {};
-
-template<class T>
-struct IsStrong<T, std::void_t<Base<T>>> : Bool<is_type_template<Base<T>, Strong>> {};
+template<class T, class = void>
+constexpr auto is_strong = false;
 
 template<class T>
-constexpr auto is_strong = IsStrong<std::remove_const_t<T>>{};
+constexpr auto is_strong<T, std::void_t<Base<T>>> = is_type_template<Base<T>, Strong>;
 
 template<class, class = void>
 struct IsOpaque : False {};
diff --git a/src/strong17.lib/strong17/Strong.weaken.h b/src/strong17.lib/strong17/Strong.weaken.h
index 2e64f45..64f44c7 100644
--- a/src/strong17.lib/strong17/Strong.weaken.h
+++ b/src/strong17.lib/strong17/Strong.weaken.h
@@ -18,11 +18,11 @@ using meta17::UnwrapType;
 
 /// like extractValue, but does nothing for non-strong types
 template<class S>
-constexpr auto weakenType(Type<S> = {}) -> std::enable_if_t<is_strong<S>.v, Type<ExtractValue<Base<S>>>> {
+constexpr auto weakenType(Type<S> = {}) -> std::enable_if_t<is_strong<S>, Type<ExtractValue<Base<S>>>> {
     return {};
 }
 template<class T>
-constexpr auto weakenType(Type<T> = {}) -> std::enable_if_t<!is_strong<T>.v, Type<T>> {
+constexpr auto weakenType(Type<T> = {}) -> std::enable_if_t<!is_strong<T>, Type<T>> {
     return {};
 }
 template<class S>
diff --git a/src/strong17.lib/strong17/strong17.tests.qbs b/src/strong17.lib/strong17/strong17.tests.qbs
index 181c003..688cd11 100644
--- a/src/strong17.lib/strong17/strong17.tests.qbs
+++ b/src/strong17.lib/strong17/strong17.tests.qbs
@@ -16,6 +16,7 @@ Application {
         "Strong.inspect.test.cpp",
         "Strong.make.test.cpp",
         "Strong.manip.test.cpp",
+        "Strong.opaque.test.cpp",
         "Strong.ops.test.cpp",
         "Strong.ostream.cpp",
         "Strong.test.cpp",
diff --git a/src/tuple17.lib/tuple17/Tuple.h b/src/tuple17.lib/tuple17/Tuple.h
index f1690f8..c23b2a3 100644
--- a/src/tuple17.lib/tuple17/Tuple.h
+++ b/src/tuple17.lib/tuple17/Tuple.h
@@ -250,12 +250,12 @@ struct Tuple {
 
     template<class F, size_t... Is>
     constexpr void visitIndexTypes(IndexPack<Is...>, F&& f) {
-        (f(_const<Is>, type_at<Is>), ...);
+        (f(_const<Is>, type<Ts>), ...);
     }
 
     template<class F, size_t... Is>
     constexpr void visitIndexTypes(IndexPack<Is...>, F&& f) const {
-        (f(_const<Is>, type_at<Is>), ...);
+        (f(_const<Is>, type<Ts>), ...);
     }
 
     template<size_t I>
diff --git a/src/tuple17.lib/tuple17/tuple17.qbs b/src/tuple17.lib/tuple17/tuple17.qbs
index ae0c931..b2f1240 100644
--- a/src/tuple17.lib/tuple17/tuple17.qbs
+++ b/src/tuple17.lib/tuple17/tuple17.qbs
@@ -1,6 +1,9 @@
 import qbs
 
 Product {
+    Depends { name: "cpp" }
+    Depends { name: "meta17" }
+
     files: [
         "Tuple.h",
         "Tuple.make.h",
diff --git a/src/variant17.lib/variant17/Variant.h b/src/variant17.lib/variant17/Variant.h
index db2db36..db26bcd 100644
--- a/src/variant17.lib/variant17/Variant.h
+++ b/src/variant17.lib/variant17/Variant.h
@@ -29,6 +29,7 @@ using meta17::indexPackFor;
 using meta17::to_type_pack;
 using meta17::type;
 using meta17::Type;
+using meta17::type_head;
 using meta17::type_pack;
 using meta17::TypeHead;
 using meta17::TypePack;
@@ -59,40 +60,98 @@ auto selectType() {
 template<size_t N>
 using SelectType = UnwrapType<decltype(selectType<N>())>;
 
-/// Variant != std::variant
-/// * unchecked invalid state (only destruction is valid!)
-/// * simple recursive vistor
-/// * allows uncheck casts (you have to check before!)
-/// * sizeof(index) limits
+/// VariantWhich is an enum-like type used in Variant to determine which type is currently present in the Variant.
 template<class... Ts>
-struct Variant {
+struct VariantWhich {
     static constexpr auto pack = to_type_pack<Ts...>;
     static constexpr auto indices = indexPackFor(pack);
-    using First = TypeHead<decltype(pack)>;
     using WhichValue = UnwrapType<SelectType<sizeof...(Ts)>>; // enough for npos!
-    enum { npos = sizeof...(Ts) }; // invalid state after exception - only destruction checks!
 
-    struct Which {
-        explicit constexpr Which(WhichValue v)
-            : value(v) {}
+    constexpr VariantWhich() = default;
+    explicit constexpr VariantWhich(WhichValue v)
+        : value(v) {}
+
+    constexpr operator WhichValue() const { return value; }
+
+    constexpr bool operator==(VariantWhich w) const { return w.value == value; }
+    constexpr bool operator!=(VariantWhich w) const { return w.value != value; }
+
+    template<class T>
+    constexpr bool operator==(Type<T>) const {
+        return of<T>() == *this;
+    }
+    template<class T>
+    constexpr bool operator!=(Type<T>) const {
+        return of<T>() != *this;
+    }
+
+    template<class T>
+    constexpr static auto of(Type<T> = {}) -> VariantWhich {
+        return VariantWhich{static_cast<WhichValue>(indexedTypePackIndexOf<T>(pack, indices))};
+    }
+
+    template<class F>
+    constexpr auto visit(F&& f) -> decltype(auto) {
+        return visitImpl(*this, std::forward<F>(f));
+    }
+    template<class F>
+    constexpr auto visit(F&& f) const -> decltype(auto) {
+        return visitImpl(*this, std::forward<F>(f));
+    }
+
+    /// overloaded visitor
+    template<class F, class F2, class... Fs>
+    constexpr auto visit(F&& f, F2&& f2, Fs&&... fs) -> decltype(auto) {
+        return visit(Overloaded{std::forward<F>(f), std::forward<F2>(f2), std::forward<Fs>(fs)...});
+    }
+    template<class F, class F2, class... Fs>
+    constexpr auto visit(F&& f, F2&& f2, Fs&&... fs) const -> decltype(auto) {
+        return visit(Overloaded{std::forward<F>(f), std::forward<F2>(f2), std::forward<Fs>(fs)...});
+    }
 
-        constexpr operator WhichValue() const { return value; }
+private:
+    WhichValue value{};
 
-        constexpr bool operator==(Which w) const { return w.value == value; }
-        constexpr bool operator!=(Which w) const { return w.value != value; }
+    template<class V, class F>
+    static constexpr auto visitImpl(V&& v, F&& f) -> decltype(auto) {
+        using R = std::remove_cv_t<decltype(f(type_head<decltype(pack)>))>;
+        if constexpr (type<R> == type<void>)
+            visitVoidImpl(std::forward<V>(v), std::forward<F>(f), indices);
+        else
+            return visitRecursiveImpl(std::forward<V>(v), std::forward<F>(f), pack, indices);
+    }
 
-        template<class T>
-        constexpr bool operator==(Type<T>) const {
-            return whichOf<T>() == *this;
+    template<class V, class F, size_t... Is>
+    static constexpr auto visitVoidImpl(V&& v, F&& f, IndexPack<Is...>) {
+        return (void)((Is == v ? (f(type<Ts>), true) : false) || ...);
+    }
+    template<class V, class F, class T, class... TTs, size_t I, size_t... Is>
+    static constexpr auto visitRecursiveImpl(V&& v, F&& f, TypePack<T, TTs...>, IndexPack<I, Is...>) -> decltype(auto) {
+        if (I == v) {
+            return f(type<T>);
         }
-        template<class T>
-        constexpr bool operator!=(Type<T>) const {
-            return whichOf<T>() != *this;
+        if constexpr (0 != sizeof...(TTs)) {
+            return visitRecursiveImpl(std::forward<V>(v), std::forward<F>(f), type_pack<TTs...>, index_pack<Is...>);
+        }
+        else {
+            UNREACHABLE();
         }
+    }
+};
 
-    private:
-        WhichValue value;
-    };
+/// Variant != std::variant
+/// * unchecked invalid state (only destruction is valid!)
+/// * simple recursive vistor
+/// * allows uncheck casts (you have to check before!)
+/// * sizeof(index) limits
+template<class... Ts>
+struct Variant {
+    using Which = VariantWhich<Ts...>;
+    static constexpr auto pack = Which::pack;
+    static constexpr auto indices = Which::indices;
+    using First = TypeHead<decltype(pack)>;
+    using WhichValue = typename Which::WhichValue;
+    enum { npos = sizeof...(Ts) }; // invalid state after exception - only destruction checks!
 
 private:
     std::aligned_union_t<0, Ts...> m{};
@@ -171,7 +230,7 @@ struct Variant {
     Variant(T&& t) {
         static_assert(containsOf<BT>(pack), "type not part of variant");
         constructOf(type<BT>, std::forward<T>(t));
-        whichValue = whichOf<BT>();
+        whichValue = whichOf(type<BT>);
     }
 
     /// inplace construct of type
@@ -179,7 +238,7 @@ struct Variant {
     Variant(Type<T>, Args&&... args) {
         static_assert(containsOf<T>(pack), "type not part of variant");
         constructOf(type<T>, std::forward<Args>(args)...);
-        whichValue = whichOf<T>();
+        whichValue = whichOf(type<T>);
     }
 
     template<size_t I, class... Args>
@@ -207,12 +266,12 @@ struct Variant {
         if (whichValue != npos) destruct();
         whichValue = npos;
         constructOf(type<T>, std::forward<Args>(args)...);
-        whichValue = whichOf<T>();
+        whichValue = whichOf(type<T>);
     }
 
     template<class T>
     constexpr static auto whichOf(Type<T> = {}) -> Which {
-        return Which{static_cast<WhichValue>(indexedTypePackIndexOf<T>(pack, indices))};
+        return Which::of(type<T>);
     }
 
     template<size_t I>
diff --git a/src/variant17.lib/variant17/Variant.trait.h b/src/variant17.lib/variant17/Variant.trait.h
index e62b708..164fad8 100644
--- a/src/variant17.lib/variant17/Variant.trait.h
+++ b/src/variant17.lib/variant17/Variant.trait.h
@@ -9,4 +9,10 @@ constexpr auto is_variant = false;
 template<class... Ts>
 constexpr auto is_variant<Variant<Ts...>> = true;
 
+template<class T>
+constexpr auto is_variant_which = false;
+
+template<class... Ts>
+constexpr auto is_variant_which<VariantWhich<Ts...>> = true;
+
 } // namespace variant17
diff --git a/src/variant17.lib/variant17/Variant.trait.test.cpp b/src/variant17.lib/variant17/Variant.trait.test.cpp
index de0d50a..0a6333e 100644
--- a/src/variant17.lib/variant17/Variant.trait.test.cpp
+++ b/src/variant17.lib/variant17/Variant.trait.test.cpp
@@ -8,14 +8,21 @@ using namespace variant17;
 TEST(Variant, trait) {
     using T = Variant<int, double, char, short, bool>;
     static_assert(is_variant<T>);
+    static_assert(!is_variant_which<T>);
+
+    static_assert(!is_variant<T::Which>);
+    static_assert(is_variant_which<T::Which>);
 
     struct S {
         int i;
     };
     static_assert(!is_variant<S>);
+    static_assert(!is_variant_which<S>);
 
     using P = std::pair<int, double>;
     static_assert(!is_variant<P>);
+    static_assert(!is_variant_which<P>);
 
     static_assert(!is_variant<int>);
+    static_assert(!is_variant_which<int>);
 }