Update based on internet feedback

Author: MCGallaspy

README.rst

@@ -490,7 +490,7 @@ you'll probably want to use a library like
 the older `MPL <http://www.boost.org/doc/libs/1_61_0/libs/mpl/doc/index.html>`_
 or the newer `boost::hana <http://www.boost.org/doc/libs/1_61_0/libs/hana/doc/html/index.html>`_.
 
-More case studies to come!
+Some readers have taken umbrage with this example -- see my thoughts in the issues.
 
 Case Study 2: Building an awesome event interface
 -------------------------------------------------
@@ -616,6 +616,24 @@ The big takeaway here is that ``void_t`` can be used to really easily determine
 Along with ``enable_if`` (which can also be used for this purpose, but the implementation is much more verbose)
 we can start building much more complex data structures and metafunctions.
 
+Some readers have pointed out that ``count`` can be implemented with fewer template instantiations.
+And they're right! So check out this alternate implementation that doesn't use SFINAE at all:
+
+.. code:: c++
+
+    /* Alternate implementation uses fewer template instantiations */
+    template <typename... Elts>
+    struct different_count;
+
+    template <typename... Elts>
+    struct different_count<type_list<Elts...>> : std::integral_constant<int, sizeof...(Elts)> {};
+
+We only define a specialization here -- you can't instantiate ``different_count`` with anything other than a
+``type_list``. This is an example of pattern matching, which we'll see used to good effect in the next example!
+The interesting thing to note here is that matching the pattern ``type_list<Elts...>`` actually unpacks ``Elts`` so
+that we can use it elsewhere in the template, namely as the argument of ``sizeof...``, which counts the number of
+types in a parameter pack.
+    
 Here's another metafunction that we'll be using:
 
 .. code:: c++

case_study_2.cpp

@@ -68,8 +68,11 @@ int main() {
     dispatcher_2::post(spiderman);
     cout << endl;
 
-    cout << repr_1 + " has count: " << count<listeners_1>::value << endl;
-    cout << repr_2 + " has count: " << count<listeners_2>::value << endl;
+    cout << repr_1 + " has count: " << different_count<listeners_1>::value << endl;
+    cout << repr_2 + " has count: " << different_count<listeners_2>::value << endl;
+    cout << "type_list<> has count: " << different_count<type_list<>>::value << endl;
+    // Another error -- we can *only* instantiate different_count with a type_list.
+    // cout << "<int, int, double> has count: " << different_count<int, int, double>::value << endl;
     cout << endl;
 
     dispatcher_1::post(JustBeforeReturn{});

case_study_2.hpp

@@ -33,11 +33,17 @@ template <typename T>
 struct count<T, void_t<typename T::tail>> :
     std::integral_constant<int, 1 + count<typename T::tail>()> {};
 
+/* Alternate implementation uses fewer template instantiations */
+template <typename... Elts>
+struct different_count;
+
+template <typename... Elts>
+struct different_count<type_list<Elts...>> : std::integral_constant<int, sizeof...(Elts)> {};
 
 /* has_tail predicate */
 template <typename T>
-struct has_tail :    /*    predicate     */  /*  if true   */ /*  if false */
-    std::conditional<(count<T>::value == 1), std::false_type, std::true_type>::type {};
+struct has_tail :    /*         predicate          */  /*  if true   */ /*  if false */
+    std::conditional<(different_count<T>::value <= 1), std::false_type, std::true_type>::type {};
 
 
 /* has_handler predicate */