├── C++_TMP
    ├── CMakeLists.txt
    ├── variadics.h
    ├── policies.h
    ├── sequences.h
    ├── common.h
    ├── traits.h
    ├── member_detection.h
    ├── compile_time_computation.h
    ├── main.cpp
    ├── solutions.h
    └── tuple_cat.h
├── .gitignore
├── LICENSE
└── README.md


/C++_TMP/CMakeLists.txt:
--------------------------------------------------------------------------------
1 | cmake_minimum_required(VERSION 3.3)
2 | project(TMP)
3 | 
4 | set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++14")
5 | 
6 | set(SOURCE_FILES main.cpp variadics.h compile_time_computation.h common.h traits.h member_detection.h sequences.h policies.h tuple_cat.h solutions.h)
7 | add_executable(TMP ${SOURCE_FILES})


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | # Compiled Object files
 2 | *.slo
 3 | *.lo
 4 | *.o
 5 | *.obj
 6 | 
 7 | # Precompiled Headers
 8 | *.gch
 9 | *.pch
10 | 
11 | # Compiled Dynamic libraries
12 | *.so
13 | *.dylib
14 | *.dll
15 | 
16 | # Fortran module files
17 | *.mod
18 | 
19 | # Compiled Static libraries
20 | *.lai
21 | *.la
22 | *.a
23 | *.lib
24 | 
25 | # Executables
26 | *.exe
27 | *.out
28 | *.app
29 | 
30 | # CLion folders
31 | .idea/
32 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) 2015 Sasha Goldshtein
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 
23 | 


--------------------------------------------------------------------------------
/C++_TMP/variadics.h:
--------------------------------------------------------------------------------
 1 | //
 2 | // Created by Sasha Goldshtein on 09/12/2015.
 3 | //
 4 | 
 5 | #ifndef TMP_VARIADICS_H
 6 | #define TMP_VARIADICS_H
 7 | 
 8 | #include <iostream>
 9 | #include <type_traits>
10 | #include <stdexcept>
11 | #include <string>
12 | 
13 | namespace variadics {
14 | 
15 |     void print() {}
16 | 
17 |     template <typename T, typename... Ts>
18 |     void print(T&& v, Ts&&... vs) {
19 |         std::cout << v << '\n';
20 |         print(std::forward<Ts>(vs)...);
21 |     }
22 | 
23 |     void printf(std::string const& format) {
24 |         for (auto c : format) {
25 |             if (c == '%')
26 |                 throw std::logic_error("too many format specifiers provided");
27 | 
28 |             std::cout << c;
29 |         }
30 |     }
31 | 
32 |     template <typename T, typename... Rest>
33 |     void printf(std::string const& format, T&& t, Rest&&... rest) {
34 |         for (auto i = 0ull; i < format.size(); ++i) {
35 |             if (format[i] == '%') {
36 |                 std::cout << std::forward<T>(t);
37 |                 printf(format.substr(i+1), std::forward<Rest>(rest)...);
38 |                 return;
39 |             } else {
40 |                 std::cout << format[i];
41 |             }
42 |         }
43 |         throw std::logic_error("too many parameters provided");
44 |     }
45 | 
46 | }
47 | 
48 | #endif //TMP_VARIADICS_H
49 | 


--------------------------------------------------------------------------------
/C++_TMP/policies.h:
--------------------------------------------------------------------------------
 1 | //
 2 | // Created by Sasha Goldshtein on 12/13/15.
 3 | //
 4 | 
 5 | #ifndef TMP_POLICIES_H
 6 | #define TMP_POLICIES_H
 7 | 
 8 | #include <stdexcept>
 9 | 
10 | namespace policies {
11 | 
12 |     template <typename T, typename SafetyPolicy>
13 |     class smart_ptr {
14 |         T* ptr_;
15 |     public:
16 |         smart_ptr(T* ptr) : ptr_{ ptr } {
17 |             SafetyPolicy::test(ptr);
18 |         }
19 | 
20 |         T& operator*() {
21 |             SafetyPolicy::test(ptr_);
22 |             return *ptr_;
23 |         }
24 | 
25 |         T const& operator*() const {
26 |             SafetyPolicy::test(ptr_);
27 |             return *ptr_;
28 |         }
29 | 
30 |         void reset(T* ptr) {
31 |             SafetyPolicy::test(ptr_);
32 |             ptr_ = ptr;
33 |         }
34 | 
35 |         ~smart_ptr() {
36 |             delete ptr_;
37 |         }
38 |     };
39 | 
40 |     struct unsafe_policy {
41 |         static void test(void*) {}
42 |     };
43 | 
44 |     struct non_null_policy {
45 |         static void test(void* ptr) {
46 |             if (ptr == nullptr) {
47 |                 throw std::invalid_argument("pointer was null");
48 |             }
49 |         }
50 |     };
51 | 
52 |     template <typename T>
53 |     using unsafe_ptr = smart_ptr<T, unsafe_policy>;
54 | 
55 |     template <typename T>
56 |     using non_null_ptr = smart_ptr<T, non_null_policy>;
57 | 
58 | }
59 | 
60 | #endif //TMP_POLICIES_H
61 | 


--------------------------------------------------------------------------------
/C++_TMP/sequences.h:
--------------------------------------------------------------------------------
 1 | //
 2 | // Created by Sasha Goldshtein on 12/13/15.
 3 | //
 4 | 
 5 | #ifndef TMP_SEQUENCES_H
 6 | #define TMP_SEQUENCES_H
 7 | 
 8 | #include <tuple>
 9 | 
10 | #include "variadics.h"
11 | 
12 | namespace sequences {
13 | 
14 |     template<size_t... Ns>
15 |     struct int_seq {
16 |         constexpr static size_t length = sizeof...(Ns);
17 |         using type = int_seq<Ns...>;
18 |     };
19 | 
20 |     template <size_t, typename>
21 |     struct push_front_seq;
22 | 
23 |     template <size_t Head, size_t... Tail>
24 |     struct push_front_seq<Head, int_seq<Tail...>> {
25 |         using type = int_seq<Head, Tail...>;
26 |     };
27 | 
28 |     template <size_t, typename>
29 |     struct push_back_seq;
30 | 
31 |     template <size_t Tail, size_t... Head>
32 |     struct push_back_seq<Tail, int_seq<Head...>> {
33 |         using type = int_seq<Head..., Tail>;
34 |     };
35 | 
36 |     template <size_t N>
37 |     struct make_seq {
38 |         using type = typename push_back_seq<N, typename make_seq<N-1>::type>::type;
39 |     };
40 | 
41 |     template <>
42 |     struct make_seq<0> {
43 |         using type = int_seq<0>;
44 |     };
45 | 
46 |     template <size_t N>
47 |     using make_index_seq = typename make_seq<N-1>::type;
48 | 
49 |     template <typename Tup, size_t... N>
50 |     void print_tuple(Tup const& tup, int_seq<N...>) {
51 |         variadics::print(std::get<N>(tup)...);
52 |     }
53 | 
54 |     template <typename Tup>
55 |     void print_tuple(Tup const& tup) {
56 |         constexpr size_t size = std::tuple_size<Tup>::value;
57 |         print_tuple(tup, typename make_seq<size-1>::type{});
58 |     }
59 | 
60 | }
61 | 
62 | #endif //TMP_SEQUENCES_H
63 | 


--------------------------------------------------------------------------------
/C++_TMP/common.h:
--------------------------------------------------------------------------------
 1 | //
 2 | // Created by Sasha Goldshtein on 09/12/2015.
 3 | //
 4 | 
 5 | #ifndef TMP_COMMON_H
 6 | #define TMP_COMMON_H
 7 | 
 8 | template <typename T>
 9 | struct is {
10 |     using type = T;
11 | };
12 | 
13 | template <bool B>
14 | struct bool_t : is<bool_t<B>> {
15 |     constexpr operator bool() const { return B; }
16 |     constexpr static bool value = B;
17 | };
18 | 
19 | using true_t = bool_t<true>;
20 | using false_t = bool_t<false>;
21 | 
22 | template <typename, typename>
23 | struct same_t : false_t {};
24 | 
25 | template <typename T>
26 | struct same_t<T, T> : true_t {};
27 | 
28 | template <typename T1, typename T2>
29 | constexpr bool same_v = typename same_t<T1, T2>::type{};
30 | 
31 | template <bool Condition, typename IfTrue, typename IfFalse>
32 | struct select_t;
33 | 
34 | template <typename IfTrue, typename IfFalse>
35 | struct select_t<true, IfTrue, IfFalse> : is<IfTrue> {};
36 | 
37 | template <typename IfTrue, typename IfFalse>
38 | struct select_t<false, IfTrue, IfFalse> : is<IfFalse> {};
39 | 
40 | template <typename>
41 | struct integral_t : false_t {};
42 | 
43 | template <> struct integral_t<signed char> : true_t {};
44 | template <> struct integral_t<unsigned char> : true_t {};
45 | template <> struct integral_t<short> : true_t {};
46 | template <> struct integral_t<unsigned short> : true_t {};
47 | template <> struct integral_t<int> : true_t {};
48 | template <> struct integral_t<unsigned int> : true_t {};
49 | template <> struct integral_t<long> : true_t {};
50 | template <> struct integral_t<unsigned long> : true_t {};
51 | template <> struct integral_t<long long> : true_t {};
52 | template <> struct integral_t<unsigned long long> : true_t {};
53 | 
54 | template <bool, typename T = void>
55 | struct allow_if_t {};
56 | 
57 | template <typename T>
58 | struct allow_if_t<true, T> : is<T> {};
59 | 
60 | template <typename T>
61 | T&& val_of_t();
62 | 
63 | #endif //TMP_COMMON_H
64 | 


--------------------------------------------------------------------------------
/C++_TMP/traits.h:
--------------------------------------------------------------------------------
 1 | //
 2 | // Created by Sasha Goldshtein on 12/11/15.
 3 | //
 4 | 
 5 | #ifndef TMP_TRAITS_H
 6 | #define TMP_TRAITS_H
 7 | 
 8 | #include <string>
 9 | #include <cctype>
10 | 
11 | namespace traits {
12 | 
13 |     namespace detail {
14 |         // Source: http://en.cppreference.com/w/cpp/string/char_traits
15 |         struct ci_char_traits : public std::char_traits<char> {
16 |             static bool eq(char c1, char c2) {
17 |                 return std::toupper(c1) == std::toupper(c2);
18 |             }
19 | 
20 |             static bool lt(char c1, char c2) {
21 |                 return std::toupper(c1) < std::toupper(c2);
22 |             }
23 | 
24 |             static int compare(char const* s1, char const* s2, size_t n) {
25 |                 while (n-- != 0) {
26 |                     if (std::toupper(*s1) < std::toupper(*s2)) return -1;
27 |                     if (std::toupper(*s1) > std::toupper(*s2)) return 1;
28 |                     ++s1;
29 |                     ++s2;
30 |                 }
31 |                 return 0;
32 |             }
33 | 
34 |             static char const* find(char const* s, int n, char a) {
35 |                 auto const ua(std::toupper(a));
36 |                 while (n-- != 0) {
37 |                     if (std::toupper(*s) == ua)
38 |                         return s;
39 |                     s++;
40 |                 }
41 |                 return nullptr;
42 |             }
43 |         };
44 | 
45 |         template <typename InIt, typename OutIt>
46 |         OutIt copy_helper(InIt first, InIt last, OutIt out, false_t) {
47 |             std::cout << "using slow copy_helper for OutIt = " << typeid(OutIt).name() << '\n';
48 |             for (; first != last; ++first, ++out) {
49 |                 *out = *first;
50 |             }
51 |             return out;
52 |         }
53 | 
54 |         template <typename InIt, typename OutIt>
55 |         OutIt copy_helper(InIt first, InIt last, OutIt out, true_t) {
56 |             std::cout << "using fast copy_helper for OutIt = " << typeid(OutIt).name() << '\n';
57 |             size_t count = (last - first);
58 |             std::memmove(out, first, count * sizeof(*first));
59 |             return out + count;
60 |         }
61 | 
62 |         template <typename InIt, typename OutIt>
63 |         struct is_safe_to_memmove_iter {
64 |             using decayed_in_t = std::decay_t<decltype(*val_of_t<InIt>())>;
65 |             using decayed_out_t = std::decay_t<decltype(*val_of_t<OutIt>())>;
66 |             using type = typename bool_t<
67 |                     same_v<decayed_in_t, decayed_out_t> &&
68 |                     std::is_pointer<InIt>::value &&
69 |                     std::is_trivially_copy_assignable<decayed_in_t>::value
70 |             >::type;
71 |         };
72 | 
73 |         template <typename InIt, typename OutIt>
74 |         using is_safe_to_memmove_iter_t = typename is_safe_to_memmove_iter<InIt, OutIt>::type;
75 |     }
76 | 
77 |     typedef std::basic_string<char, detail::ci_char_traits> ci_string;
78 | 
79 |     template <typename InIt, typename OutIt>
80 |     OutIt copy(InIt first, InIt last, OutIt out) {
81 |         return detail::copy_helper(first, last, out,
82 |                                    typename detail::is_safe_to_memmove_iter_t<InIt, OutIt>::type{});
83 |     }
84 | }
85 | 
86 | #endif //TMP_TRAITS_H
87 | 


--------------------------------------------------------------------------------
/C++_TMP/member_detection.h:
--------------------------------------------------------------------------------
  1 | //
  2 | // Created by Sasha Goldshtein on 12/13/15.
  3 | //
  4 | 
  5 | #ifndef TMP_MEMBER_DETECTION_H
  6 | #define TMP_MEMBER_DETECTION_H
  7 | 
  8 | #include <vector>
  9 | #include <string>
 10 | 
 11 | namespace member_detection {
 12 | 
 13 |     namespace detail {
 14 | 
 15 |         template <typename T>
 16 |         using void_t = void;
 17 | 
 18 |         template <typename T, typename = void>
 19 |         struct is_container3_helper : false_t {
 20 |         };
 21 | 
 22 |         template <typename T>
 23 |         struct is_container3_helper<T, void_t<typename T::iterator>> : true_t {
 24 |         };
 25 | 
 26 |         template <typename T>
 27 |         constexpr auto is_container4_helper(int) -> decltype(val_of_t<typename T::iterator>(), true) {
 28 |             return true;
 29 |         }
 30 | 
 31 |         template <typename T>
 32 |         constexpr auto is_container4_helper(...) {
 33 |             return false;
 34 |         }
 35 | 
 36 |         template <typename T>
 37 |         void dump(std::ostream& os, T const& val);
 38 | 
 39 |         template <typename T>
 40 |         void dump(std::ostream& os, T const& val, true_t) {
 41 |             os << "<<< begin container of type " << typeid(T).name() << " >>>\n";
 42 |             for (auto const& elem : val) {
 43 |                 dump(os, elem);
 44 |             }
 45 |             os << "<<< end container >>>\n";
 46 |         }
 47 | 
 48 |         template <typename T>
 49 |         void dump(std::ostream& os, T const& val, false_t) {
 50 |             os << "plain value: " << val << '\n';
 51 |         }
 52 | 
 53 |         template <typename T>
 54 |         void dump(std::ostream& os, T const& val) {
 55 |             dump(os, val, bool_t<is_container3_helper<T>::value>{});
 56 |         }
 57 | 
 58 |     }
 59 | 
 60 |     template <typename T>
 61 |     struct is_container1 {
 62 | 
 63 |         // Two types whose sizes are guaranteed to differ according to The Standard
 64 |         using when_false_t = short;
 65 |         using when_true_t = long;
 66 | 
 67 |         template <typename S> static when_false_t test(...);
 68 |         template <typename S> static when_true_t test(typename S::iterator*);
 69 | 
 70 |         constexpr static bool value = sizeof(test<T>(nullptr)) == sizeof(when_true_t);
 71 | 
 72 |     };
 73 | 
 74 |     template <typename T>
 75 |     struct is_container2 {
 76 | 
 77 |         template <typename S, typename = typename S::iterator>
 78 |         static std::true_type test(S&&);
 79 |         static std::false_type test(...);
 80 | 
 81 |         constexpr static bool value = decltype(test(val_of_t<T>()))::value;
 82 | 
 83 |     };
 84 | 
 85 |     template <typename T>
 86 |     struct is_container3 : detail::is_container3_helper<T> {
 87 |     };
 88 | 
 89 |     template <typename T>
 90 |     using is_container4 = bool_t<detail::is_container4_helper<T>(0)>;
 91 | 
 92 |     template <template <typename> class Detector>
 93 |     void test() {
 94 |         static_assert(!Detector<int>::value, "");
 95 |         static_assert(Detector<std::vector<int>>::value, "");
 96 |         static_assert(Detector<std::string>::value, "");
 97 |         static_assert(!Detector<float>::value, "");
 98 |     }
 99 | 
100 |     template <typename T>
101 |     void dump(std::ostream& os, T const& val) {
102 |         detail::dump(os, val);
103 |     }
104 | 
105 | }
106 | 
107 | #endif //TMP_MEMBER_DETECTION_H
108 | 


--------------------------------------------------------------------------------
/C++_TMP/compile_time_computation.h:
--------------------------------------------------------------------------------
  1 | //
  2 | // Created by Sasha Goldshtein on 09/12/2015.
  3 | //
  4 | 
  5 | #ifndef TMP_COMPILE_TIME_COMPUTATION_H
  6 | #define TMP_COMPILE_TIME_COMPUTATION_H
  7 | 
  8 | #include <vector>
  9 | #include <string>
 10 | #include <algorithm>
 11 | #include <stdexcept>
 12 | #include <initializer_list>
 13 | 
 14 | #include "common.h"
 15 | #include "variadics.h"
 16 | 
 17 | namespace compiletime {
 18 | 
 19 |     namespace detail {
 20 | 
 21 |         class cstr {
 22 |             char const* start_;
 23 |             size_t length_;
 24 |         public:
 25 |             template <size_t N>
 26 |             constexpr cstr(char const(&str)[N]) : start_(str), length_(N) {
 27 |             }
 28 |             constexpr bool is_valid_pattern() const {
 29 |                 for (size_t i = 0; i < length_ - 1 /* null terminator */; ++i) {
 30 |                     if (start_[i] >= 'A' && start_[i] <= 'Z')
 31 |                         continue;
 32 | 
 33 |                     if (start_[i] >= 'a' && start_[i] <= 'z')
 34 |                         continue;
 35 | 
 36 |                     if (start_[i] == '*' || start_[i] == '?')
 37 |                         continue;
 38 | 
 39 |                     return false;
 40 |                 }
 41 |                 return true;
 42 |             }
 43 |             constexpr size_t count_of(char c) const {
 44 |                 size_t count = 0;
 45 |                 for (size_t i = 0; i < length_; ++i) {
 46 |                     if (start_[i] == c)
 47 |                         ++count;
 48 |                 }
 49 |                 return count;
 50 |             }
 51 |         };
 52 | 
 53 |         template <typename...> struct largest_t;
 54 | 
 55 |         template <typename T> struct largest_t<T> : is<T> {};
 56 | 
 57 |         template <typename T1, typename T2, typename... Rest>
 58 |         struct largest_t<T1, T2, Rest...> {
 59 |             using type = typename select_t<(sizeof(T1) < sizeof(T2)),
 60 |                     typename largest_t<T2, Rest...>::type,
 61 |                     typename largest_t<T1, Rest...>::type
 62 |                     >::type;
 63 |         };
 64 | 
 65 |         void largest_test() {
 66 |             static_assert(same_v<typename largest_t<int>::type, int>, "");
 67 |             static_assert(same_v<typename largest_t<int, double>::type, double>, "");
 68 |             static_assert(same_v<typename largest_t<char, long long, long>::type, long long>, "");
 69 |         }
 70 | 
 71 |         template <template <class> class>
 72 |         constexpr bool and_f() {
 73 |             return true;
 74 |         }
 75 | 
 76 |         template <template <class> class Op, typename T, typename... Types>
 77 |         constexpr bool and_f() {
 78 |             return Op<T>::value && and_f<Op, Types...>();
 79 |         };
 80 | 
 81 |         template <typename T> struct size_smaller_than_five { constexpr static bool value = sizeof(T) < 5; };
 82 | 
 83 |         void andf_test() {
 84 |             static_assert(and_f<size_smaller_than_five>(), "");
 85 |             static_assert(and_f<size_smaller_than_five, int>(), "");
 86 |             static_assert(and_f<size_smaller_than_five, int, char, char, float>(), "");
 87 |             static_assert(!and_f<size_smaller_than_five, long long, char, char, float>(), "");
 88 |         }
 89 |     }
 90 | 
 91 | #define FIND_FILES(pattern) \
 92 |     static_assert(compiletime::detail::cstr{ pattern }.is_valid_pattern(), "pattern contains invalid characters"); \
 93 |     compiletime::find_files(pattern);
 94 | 
 95 |     void find_files(std::string const& pattern) {
 96 |         if (!std::all_of(pattern.begin(), pattern.end(), [](char c) {
 97 |             return isalnum(c) || c == '*' || c == '?';
 98 |         })) {
 99 |             throw std::invalid_argument("pattern contains invalid characters");
100 |         }
101 |         // The actual work would go here
102 |     }
103 | 
104 |     template <typename... Types, typename = allow_if_t<detail::and_f<integral_t, Types...>()>>
105 |     auto varmax(Types... args) {
106 |         using largest = typename detail::largest_t<Types...>::type;
107 |         std::initializer_list<largest> list{ static_cast<largest>(args)... };
108 |         return *std::max_element(list.begin(), list.end());
109 |     }
110 | 
111 |     template <typename... Types>
112 |     constexpr unsigned sizeof_args(Types&&...) {
113 |         return sizeof...(Types);
114 |     }
115 | 
116 | #define SAFE_PRINTF(format, ...) \
117 |     static_assert(compiletime::detail::cstr(format).count_of('%') == compiletime::sizeof_args(__VA_ARGS__), \
118 |     "number of arguments doesn't match the format string"); \
119 |     variadics::printf(format, ##__VA_ARGS__);
120 | 
121 | }
122 | 
123 | #endif //TMP_COMPILE_TIME_COMPUTATION_H
124 | 


--------------------------------------------------------------------------------
/C++_TMP/main.cpp:
--------------------------------------------------------------------------------
  1 | #include <iostream>
  2 | #include <map>
  3 | #include <vector>
  4 | #include <list>
  5 | 
  6 | #include "variadics.h"
  7 | #include "compile_time_computation.h"
  8 | #include "traits.h"
  9 | #include "policies.h"
 10 | #include "member_detection.h"
 11 | #include "sequences.h"
 12 | #include "tuple_cat.h"
 13 | 
 14 | #include "solutions.h"
 15 | 
 16 | using namespace std::string_literals;
 17 | 
 18 | template <typename Fn>
 19 | void try_and_print_exception(Fn&& fn) {
 20 |     try {
 21 |         std::forward<Fn>(fn)();
 22 |     } catch (std::exception& e) {
 23 |         std::cerr << e.what() << '\n';
 24 |     }
 25 | }
 26 | 
 27 | void variadics_test() {
 28 |     variadics::print(42, "Hello", 3.14f);
 29 |     variadics::printf("The value of pi is % and this conference is %\n", 3.14, "SDP");
 30 |     try_and_print_exception([] { variadics::printf("Missing parameter %\n"); });
 31 |     try_and_print_exception([] { variadics::printf("Too many parameters %\n", 42, 43); });
 32 | }
 33 | 
 34 | void compile_time_test() {
 35 |     auto maxval = compiletime::varmax(123ull, 4, (short)511);
 36 |     static_assert(same_v<decltype(maxval), unsigned long long>, "");
 37 |     std::cout << "maxval = " << maxval << ", type = " << typeid(maxval).name() << '\n';
 38 | 
 39 |     compiletime::find_files("what?ver*"s);
 40 |     FIND_FILES("what?ver*");
 41 |     try_and_print_exception([] { compiletime::find_files("invalid$$$"s); });
 42 |     // FIND_FILES("invalid$$$");
 43 | 
 44 |     SAFE_PRINTF("x = %\n", 42);
 45 |     // SAFE_PRINTF("%", 17, 42);
 46 | }
 47 | 
 48 | void traits_test() {
 49 |     traits::ci_string a("hello"), b("HellO");
 50 |     std::cout << "these strings are equal: " << std::boolalpha << (a == b) << '\n';
 51 | 
 52 |     struct Integer {
 53 |         Integer() {}
 54 |         Integer(int) {}
 55 |     };
 56 |     std::vector<int> v1 { 1,2,3 };
 57 |     std::vector<Integer> v2(3);
 58 |     std::vector<int> v3(3);
 59 |     std::list<int> v4(3);
 60 |     int v5[] = { 1,2,3 };
 61 |     int v6[3];
 62 | 
 63 |     traits::copy(v1.begin(), v1.end(), v2.begin());
 64 |     traits::copy(v1.begin(), v1.end(), v3.begin());
 65 |     traits::copy(v1.begin(), v1.end(), v4.begin());
 66 |     traits::copy(std::begin(v5), std::end(v5), std::begin(v6));
 67 | }
 68 | 
 69 | void policies_test() {
 70 |     try_and_print_exception([] { policies::non_null_ptr<std::string> ps{ nullptr }; });
 71 | }
 72 | 
 73 | void member_detection_test() {
 74 |     member_detection::test<member_detection::is_container1>();
 75 |     member_detection::test<member_detection::is_container2>();
 76 |     member_detection::test<member_detection::is_container3>();
 77 |     member_detection::test<member_detection::is_container4>();
 78 | 
 79 |     member_detection::dump(std::cout, 42);
 80 |     member_detection::dump(std::cout, std::vector<int>{ 1,2,3 });
 81 |     member_detection::dump(std::cout, std::vector<std::vector<int>> { {1,2}, {3,4} });
 82 | }
 83 | 
 84 | void sequences_test() {
 85 |     using namespace std::string_literals;
 86 | 
 87 |     static_assert(sequences::make_seq<4>::type::length == 5, "");
 88 |     auto tup = std::make_tuple(42, "hello"s, 3.14f);
 89 | 
 90 |     sequences::print_tuple(tup);
 91 | }
 92 | 
 93 | void solutions_test() {
 94 | 
 95 |     std::cout << solutions::lab1_direct::euclidean_distance(
 96 |             std::make_tuple(1, 0, 2),
 97 |             std::make_tuple(1, 2, 3)) << '\n';
 98 | 
 99 |     std::cout << solutions::lab1_sequences::euclidean_distance(
100 |             std::make_tuple(1, 0, 2),
101 |             std::make_tuple(1, 2, 3)) << '\n';
102 | 
103 |     auto tup = std::make_tuple(4.0, "hello", 52);
104 |     solutions::lab2::get<double>(tup) = 3.0;
105 |     std::cout << solutions::lab2::get<int>(tup) << "\n";
106 |     // This doesn't compile:
107 |     // solutions::lab2::get<char>(tup);
108 | 
109 |     std::vector<int> v{ -1, 43, 5, 42, 7 };
110 |     std::cout << *solutions::lab3::linear_search(v.begin(), v.end(), 42) << '\n';
111 |     struct non_equatable {};
112 |     std::vector<non_equatable> u(2);
113 |     // This doesn't compile, which is what we wanted:
114 |     // solutions::lab3::linear_search(u.begin(), u.end(), non_equatable{});
115 | 
116 |     static_assert(solutions::lab4::is_container_better<char[5]>::value, "");
117 |     static_assert(!solutions::lab4::is_container_better<std::string>::value, "");
118 |     static_assert(!solutions::lab4::is_container_better<std::wstring>::value, "");
119 | 
120 |     solutions::lab5::toolbar tb;
121 |     solutions::lab5::window w{ tb };
122 |     solutions::lab5::window w2{ w };
123 | 
124 |     int arr[] = { 1, 2, 3 };
125 |     auto tup2 = solutions::lab6::array_to_tuple(arr);
126 |     std::cout << std::get<0>(tup2) << '\n';
127 | 
128 |     auto invoker = [](int a, std::string const& b) {
129 |         std::cout << "a = " << a << ", b = " << b << '\n';
130 |     };
131 |     solutions::lab6::invoke(invoker, std::make_tuple(42, "hello"));
132 | }
133 | 
134 | int main() {
135 |     variadics_test();
136 |     compile_time_test();
137 |     traits_test();
138 |     policies_test();
139 |     member_detection_test();
140 |     sequences_test();
141 |     // tupcat::tuple_cat_perf(); // commented-out because it is a bit slow
142 | 
143 |     solutions_test();
144 | 
145 |     return 0;
146 | }


--------------------------------------------------------------------------------
/C++_TMP/solutions.h:
--------------------------------------------------------------------------------
  1 | //
  2 | // Created by Sasha Goldshtein on 12/13/15.
  3 | //
  4 | 
  5 | #ifndef TMP_SOLUTIONS_H
  6 | #define TMP_SOLUTIONS_H
  7 | 
  8 | #include <tuple>
  9 | #include <numeric>
 10 | #include <utility>
 11 | 
 12 | #include "member_detection.h"
 13 | 
 14 | namespace solutions {
 15 | 
 16 |     namespace lab1_direct {
 17 | 
 18 |         // Another option is to use plain function overloads on integral_constant<-1>
 19 |         // vs. the general case integral_constant<I> and do a recursive call.
 20 | 
 21 |         template <int I>
 22 |         struct helper {
 23 |             template <typename Tup1, typename Tup2>
 24 |             static double sum_squared_deltas(Tup1 const& tup1, Tup2 const& tup2) {
 25 |                 double sd = static_cast<double>(std::get<I>(tup1) - std::get<I>(tup2));
 26 |                 return sd*sd + helper<I-1>::sum_squared_deltas(tup1, tup2);
 27 |             }
 28 |         };
 29 | 
 30 |         template <>
 31 |         struct helper<-1> {
 32 |             template <typename Tup1, typename Tup2>
 33 |             static double sum_squared_deltas(Tup1 const& tup1, Tup2 const& tup2) {
 34 |                 return 0.0;
 35 |             }
 36 |         };
 37 | 
 38 |         template <typename Tup1, typename Tup2>
 39 |         auto euclidean_distance(Tup1 const &tup1, Tup2 const &tup2) {
 40 | 
 41 |             static_assert(std::tuple_size<Tup1>::value == std::tuple_size<Tup2>::value,
 42 |                           "tuples must have the same size");
 43 | 
 44 |             double ssd = helper<std::tuple_size<Tup1>::value-1>::sum_squared_deltas(tup1, tup2);
 45 |             return std::sqrt(ssd);
 46 |         }
 47 |     }
 48 | 
 49 |     namespace lab1_sequences {
 50 | 
 51 |         template <typename Tup1, typename Tup2, size_t... Ix>
 52 |         double sum_squared_deltas(Tup1 const& tup1, Tup2 const& tup2, std::index_sequence<Ix...>) {
 53 | 
 54 |             double deltas[] = { (static_cast<double>(std::get<Ix>(tup1) - std::get<Ix>(tup2)))... };
 55 |             return std::accumulate(std::begin(deltas), std::end(deltas), 0.0,
 56 |                 [](double acc, double delta) { return acc + delta*delta; });
 57 | 
 58 |         }
 59 | 
 60 |         template <typename Tup1, typename Tup2>
 61 |         auto euclidean_distance(Tup1 const& tup1, Tup2 const& tup2) {
 62 | 
 63 |             static_assert(std::tuple_size<Tup1>::value == std::tuple_size<Tup2>::value,
 64 |                           "tuples must have the same size");
 65 | 
 66 |             using ix_seq_t = std::make_index_sequence<std::tuple_size<Tup1>::value>;
 67 | 
 68 |             double ssd = sum_squared_deltas(tup1, tup2, ix_seq_t{});
 69 |             return std::sqrt(ssd);
 70 |         }
 71 | 
 72 |     }
 73 | 
 74 |     namespace lab2 {
 75 | 
 76 |         template <typename...>
 77 |         struct count;
 78 | 
 79 |         template <typename T>
 80 |         struct count<T> {
 81 |             constexpr static size_t value = 0;
 82 |         };
 83 | 
 84 |         template <typename T, typename Head, typename... Tail>
 85 |         struct count<T, Head, Tail...> {
 86 |             constexpr static size_t value =
 87 |                     (std::is_same<T, Head>::value ? 1 : 0) + count<T, Tail...>::value;
 88 |         };
 89 | 
 90 |         template <typename...>
 91 |         struct find;
 92 | 
 93 |         template <typename T>
 94 |         struct find<T> {
 95 |             // No ::value field, which causes a compile-time error
 96 |         };
 97 | 
 98 |         template <typename T, typename... Tail>
 99 |         struct find<T, T, Tail...> {
100 |             constexpr static size_t value = 0;
101 |         };
102 | 
103 |         template <typename T, typename Head, typename... Tail>
104 |         struct find<T, Head, Tail...> {
105 |             constexpr static size_t value = 1 + find<T, Tail...>::value;
106 |         };
107 | 
108 |         template <typename T, typename... Ts>
109 |         T& get(std::tuple<Ts...>& tup) {
110 |             static_assert(count<T, Ts...>::value == 1, "T must appear exactly once");
111 |             return std::get<find<T, Ts...>::value>(tup);
112 |         }
113 | 
114 |     }
115 | 
116 |     namespace lab3 {
117 | 
118 |         template <typename T, typename S>
119 |         constexpr auto has_eq_operator(int) -> decltype(std::declval<T>() == std::declval<S>(), true) {
120 |             return true;
121 |         }
122 | 
123 |         template <typename T, typename S>
124 |         constexpr bool has_eq_operator(...) {
125 |             return false;
126 |         }
127 | 
128 |         template <typename It, typename T>
129 |         It linear_search(It first, It last, T const& val, std::true_type) {
130 |             for (; first != last && !(val == *first); ++first)
131 |                 ;
132 |             return first;
133 |         }
134 | 
135 |         template <typename It, typename T>
136 |         It linear_search(It first, It last, T const& val, std::false_type) {
137 |             return last;
138 |         }
139 | 
140 |         template <typename It, typename T>
141 |         It linear_search(It first, It last, T const& val) {
142 |             using decayed_it_t = std::decay_t<decltype(*first)>;
143 |             constexpr bool ok = has_eq_operator<T, decayed_it_t>(0);
144 |             static_assert(ok, "'val' must have an equality operator with elements of the sequence (==)");
145 | 
146 |             return linear_search(first, last, val, std::integral_constant<bool, ok>{});
147 |         }
148 | 
149 |     }
150 | 
151 |     namespace lab4 {
152 | 
153 |         template <typename T>
154 |         struct is_container_better : member_detection::is_container3<T> {
155 |         };
156 | 
157 |         template <typename CharT, typename Traits, typename Allocator>
158 |         struct is_container_better<std::basic_string<CharT, Traits, Allocator>> : false_t {
159 |         };
160 | 
161 |         template <typename T, size_t N>
162 |         struct is_container_better<T[N]> : true_t {
163 |         };
164 | 
165 |     }
166 | 
167 |     namespace lab5 {
168 | 
169 |         class toolbar {
170 |         };
171 | 
172 |         class window {
173 |             toolbar toolbar_;
174 |         public:
175 |             template <
176 |                     typename Toolbar,
177 |                     typename = std::enable_if_t<
178 |                             !std::is_same<window, std::decay_t<Toolbar>>::value
179 |                     >
180 |             >
181 |             window(Toolbar&& toolbar) : toolbar_{ std::forward<Toolbar>(toolbar) } {
182 |             }
183 |             window(window const& other) {
184 |                 /* some copy construction */
185 |             }
186 |             window(window&& other) {
187 |                 /* some move construction */
188 |             }
189 |             /* some additional methods */
190 |         };
191 | 
192 |     }
193 | 
194 |     namespace lab6 {
195 | 
196 |         template <typename T, size_t N, size_t... Ix>
197 |         auto array_to_tuple(T const(&arr)[N], std::index_sequence<Ix...>) {
198 |             return std::make_tuple(arr[Ix]...);
199 |         }
200 | 
201 |         template <typename T, size_t N>
202 |         auto array_to_tuple(T const(&arr)[N]) {
203 |             return array_to_tuple(arr, std::make_index_sequence<N>{});
204 |         }
205 | 
206 |         template <typename Fn, typename Tup, size_t... Ix>
207 |         auto invoke(Fn&& fn, Tup&& tup, std::index_sequence<Ix...>) {
208 |             return std::forward<Fn>(fn)(std::get<Ix>(tup)...);
209 |         }
210 | 
211 |         template <typename Fn, typename Tup>
212 |         auto invoke(Fn&& fn, Tup&& tup) {
213 |             return invoke(std::forward<Fn>(fn), std::forward<Tup>(tup),
214 |                           std::make_index_sequence<std::tuple_size<Tup>::value>{});
215 |         }
216 | 
217 |     }
218 | 
219 | }
220 | 
221 | #endif //TMP_SOLUTIONS_H
222 | 


--------------------------------------------------------------------------------
/C++_TMP/tuple_cat.h:
--------------------------------------------------------------------------------
  1 | //
  2 | // Created by Sasha Goldshtein on 12/13/15.
  3 | //
  4 | 
  5 | #ifndef TMP_TUPLE_CAT_H
  6 | #define TMP_TUPLE_CAT_H
  7 | 
  8 | #include <tuple>
  9 | #include <chrono>
 10 | #include <vector>
 11 | #include <complex>
 12 | 
 13 | #include "sequences.h"
 14 | 
 15 | namespace tupcat
 16 | {
 17 | 	// Simple recursive implementation of tuple_cat. The recursive version concats the first
 18 | 	// two tuples and then calls "itself" recursively.
 19 | 	namespace direct
 20 | 	{
 21 |         using namespace sequences;
 22 | 
 23 | 		template <size_t... Ix1, typename LeftTuple, size_t... Ix2, typename RightTuple>
 24 | 		auto concat_two(LeftTuple&& left, RightTuple&& right, int_seq<Ix1...>, int_seq<Ix2...>)
 25 | 		{
 26 | 			return std::make_tuple(
 27 | 				std::get<Ix1>(std::forward<LeftTuple>(left))...,
 28 | 				std::get<Ix2>(std::forward<RightTuple>(right))...
 29 | 				);
 30 | 		}
 31 | 
 32 | 		template <typename HeadTuple>
 33 | 		HeadTuple&& tuple_cat(HeadTuple&& head)
 34 | 		{
 35 | 			return std::forward<HeadTuple>(head);
 36 | 		}
 37 | 
 38 | 		template <typename Head1Tuple, typename Head2Tuple, typename... TailTuples>
 39 | 		auto tuple_cat(Head1Tuple&& head1, Head2Tuple&& head2, TailTuples&&... tail)
 40 | 		{
 41 | 			return tuple_cat(
 42 | 				concat_two(
 43 | 					std::forward<Head1Tuple>(head1),
 44 | 					std::forward<Head2Tuple>(head2),
 45 | 					make_index_seq<std::tuple_size<typename std::decay<Head1Tuple>::type>::value>{},
 46 | 					make_index_seq<std::tuple_size<typename std::decay<Head2Tuple>::type>::value>{}
 47 | 				),
 48 | 				std::forward<TailTuples>(tail)...
 49 | 			);
 50 | 		}
 51 | 	}
 52 | 
 53 | 	namespace twodimensional
 54 | 	{
 55 |         using namespace sequences;
 56 | 
 57 | 		template <typename Tuples, size_t... Ix, size_t... Jx>
 58 | 		auto cat2d_all(Tuples&& tuples, int_seq<Ix...>, int_seq<Jx...>)
 59 | 		{
 60 | 			// 'tuples' is a tuple of tuples, and the index sequences help index into that
 61 | 			// tuple of tuples two-dimensionally.
 62 | 			// If originally provided with n tuples with E(k) elements each, then Ix and Jx
 63 | 			// are two index sequences (of the same length) with the following structure:
 64 | 			// Ix = 0, 0, ..., 0     , 1, 1, ...,  1     , ......, n-1, n-1, ..., n-1
 65 | 			// Jx = 0, 1, ..., E(1)-1, 0, 1, ...,  E(2)-1, ......, 0  , 1  , ..., E(n-1)-1
 66 | 			return std::make_tuple(
 67 | 				std::get<Jx>(std::get<Ix>(std::forward<Tuples>(tuples)))...
 68 | 				);
 69 | 		}
 70 | 
 71 | 		// Concatenates any number of index sequences into a single index sequence
 72 | 		template <typename... Sequences>
 73 | 		struct cat_index_sequence;
 74 | 
 75 | 		template <size_t... Indices>
 76 | 		struct cat_index_sequence<int_seq<Indices...>> : int_seq<Indices...>
 77 | 		{
 78 | 		};
 79 | 
 80 | 		template <size_t... Indices1, size_t... Indices2>
 81 | 		struct cat_index_sequence<int_seq<Indices1...>, int_seq<Indices2...>>
 82 | 			: int_seq<Indices1..., Indices2...>
 83 | 		{
 84 | 		};
 85 | 
 86 | 		template <size_t... Indices1, size_t... Indices2, typename... Sequences>
 87 | 		struct cat_index_sequence<int_seq<Indices1...>, int_seq<Indices2...>, Sequences...>
 88 | 			: cat_index_sequence<int_seq<Indices1..., Indices2...>, cat_index_sequence<Sequences...>>
 89 | 		{
 90 | 		};
 91 | 
 92 | 		// Make a sequence (I, ..., I) of size Length
 93 | 		template <size_t I, size_t Length>
 94 | 		struct make_repeated_sequence :
 95 |                 cat_index_sequence<int_seq<I>, typename make_repeated_sequence<I, Length - 1>::type>
 96 | 		{
 97 | 		};
 98 | 
 99 | 		template <size_t I>
100 | 		struct make_repeated_sequence<I, 1> : int_seq<I>
101 | 		{
102 | 		};
103 | 
104 | 		// Generates an index sequence that, for each i from 0 to sizeof...(Lengths)-1, k(i) in Lengths...,
105 | 		// is a sequence of i repeated k(i) times
106 | 		template <typename, size_t... Lengths>
107 | 		struct repeating_index_sequence;
108 | 
109 | 		template <size_t I, size_t Length>
110 | 		struct repeating_index_sequence<std::integral_constant<size_t, I>, Length>
111 | 			: make_repeated_sequence<I, Length>
112 | 		{
113 | 		};
114 | 
115 | 		template <size_t I, size_t Length, size_t... TailLengths>
116 | 		struct repeating_index_sequence<std::integral_constant<size_t, I>, Length, TailLengths...>
117 | 			: cat_index_sequence<typename make_repeated_sequence<I, Length>::type
118 | 							   , typename repeating_index_sequence<std::integral_constant<size_t, I + 1>, TailLengths...>::type>
119 | 		{
120 | 		};
121 | 
122 | 		// Generates an index sequence that concatenates make_index_sequence<k> for each k in Lengths...
123 | 		template <size_t... Lengths>
124 | 		struct variable_index_sequence;
125 | 
126 | 		template <size_t Head>
127 | 		struct variable_index_sequence<Head> : make_index_seq<Head>
128 | 		{
129 | 		};
130 | 
131 | 		template <size_t Head, size_t... Tail>
132 | 		struct variable_index_sequence<Head, Tail...>
133 | 			: cat_index_sequence<typename variable_index_sequence<Head>::type, typename variable_index_sequence<Tail...>::type>
134 | 		{
135 | 		};
136 | 
137 | 		template <typename... Tuples>
138 | 		auto tuple_cat(Tuples&&... tuples)
139 | 		{
140 | 			auto ixs = repeating_index_sequence<
141 |                     std::integral_constant<size_t, 0>,
142 |                     std::tuple_size<typename std::decay<Tuples>::type>::value...
143 |             >{};
144 | 			auto jxs = variable_index_sequence<
145 |                     std::tuple_size<typename std::decay<Tuples>::type>::value...
146 |             >{};
147 | 			return cat2d_all(std::forward_as_tuple(std::forward<Tuples>(tuples)...), ixs, jxs);
148 | 		}
149 | 	}
150 | 
151 |     namespace tests
152 |     {
153 |         using namespace sequences;
154 |         using namespace twodimensional;
155 | 
156 |         void compile_time_truths()
157 |         {
158 |             static_assert(std::is_same<
159 |                                   int_seq<0, 1, 0, 1, 2>
160 |                     , cat_index_sequence<make_index_seq<2>::type, make_index_seq<3>::type>::type
161 |                       >::value, "");
162 | 
163 |             static_assert(std::is_same<
164 |                                   int_seq<0, 1, 0, 1, 2>
165 |                     , variable_index_sequence<2, 3>::type
166 |                       >::value, "");
167 | 
168 |             static_assert(std::is_same<
169 |                                   int_seq<0, 0, 0, 0>
170 |                     , make_repeated_sequence<0, 4>::type
171 |                       >::value, "");
172 | 
173 |             static_assert(std::is_same<
174 |                                   int_seq<3, 3, 3>
175 |                     , make_repeated_sequence<3, 3>::type
176 |                       >::value, "");
177 | 
178 |             static_assert(std::is_same<
179 |                                   int_seq<0, 0, 0, 1, 1, 2, 2, 2, 2>
180 |                     , repeating_index_sequence<std::integral_constant<size_t, 0>, 3, 2, 4>::type
181 |                       >::value, "");
182 |         }
183 | 
184 | #ifdef _DEBUG
185 |         constexpr int ITERATIONS = 100000;
186 | #else
187 |         constexpr int ITERATIONS = 10000000;
188 | #endif
189 | 
190 |         template <typename Catter>
191 |         void measure(std::string const& description, Catter catter)
192 |         {
193 |             {
194 |                 std::cout << "simple tuple  ";
195 |                 auto tup1 = std::make_tuple(1, 2);
196 |                 auto tup2 = std::make_tuple('a', 4.0f);
197 |                 auto tup3 = std::make_tuple(3ull, L'c', 17);
198 |                 auto tup4 = std::make_tuple(0, 47.0);
199 |                 volatile int size = 0;
200 |                 auto start = std::chrono::high_resolution_clock::now();
201 |                 for (int i = 0; i < ITERATIONS; ++i)
202 |                 {
203 |                     auto result = catter(tup1, tup2, tup3, tup4);
204 |                     size = std::get<0>(result);
205 |                 }
206 |                 auto end = std::chrono::high_resolution_clock::now();
207 |                 std::cout << "[" << description << "] elapsed " << std::chrono::duration_cast<std::chrono::microseconds>(end - start).count() << " us\n";
208 |             }
209 | 
210 |             {
211 |                 std::cout << "complex tuple ";
212 |                 auto tup1 = std::make_tuple(17, std::string{ "hello" }, std::complex<double>(14.0, 3.5));
213 |                 auto tup2 = std::make_tuple('a', std::vector<int>{1, 2, 3}, 42);
214 |                 auto tup3 = std::make_tuple(3ull, L'c', 17);
215 |                 volatile int size = 0;
216 |                 auto start = std::chrono::high_resolution_clock::now();
217 |                 for (int i = 0; i < ITERATIONS; ++i)
218 |                 {
219 |                     auto result = catter(tup1, tup2, tup3);
220 |                     size = std::get<0>(result);
221 |                 }
222 |                 auto end = std::chrono::high_resolution_clock::now();
223 |                 std::cout << "[" << description << "] elapsed " << std::chrono::duration_cast<std::chrono::microseconds>(end - start).count() << " us\n";
224 |             }
225 |         }
226 | 
227 |     }
228 | 
229 |     void tuple_cat_perf()
230 |     {
231 |         tests::measure("simple cat  ", [](auto&&... args) { return direct::tuple_cat(args...); });
232 |         tests::measure("2d     cat", [](auto&&... args) { return twodimensional::tuple_cat(args...); });
233 |         tests::measure("empty loop", [](auto&&... args) { return std::make_tuple(1); });
234 |     }
235 | }
236 | 
237 | #endif //TMP_TUPLE_CAT_H
238 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | ### C++ Template Metaprogramming workshop
  2 | 
  3 | This document contains accompanying labs for the C++ metaprogramming workshop by [Sasha Goldshtein](http://blog.sashag.net) ([@goldshtn](https://twitter.com/goldshtn)), delivered at the [December 2015 SDP](http://www.seladeveloperpractice.com).
  4 | 
  5 | > Solutions for all labs are available in the [solutions.h](C++_TMP/solutions.h) file. Try to only consult the solutions if you get stuck in a particular lab.
  6 | 
  7 | #### Lab 1: Variadic templates -- Euclidean distance on tuples
  8 | 
  9 | `std::tuple` is a standard library type that represents a collection of heterogenous elements. It is an extension of the old-fashioned `std::pair` type for more than two types. Here are some basic operations you can perform with tuples:
 10 | 
 11 | ```
 12 | std::tuple<int, std::string, double> tup(42, "Alfred", 3.14);
 13 | tup = make_tuple(17, "Henrietta", 0.0);
 14 | std::string name = std::get<1>(tup);
 15 | ```
 16 | 
 17 | Implement the following function, that finds the Euclidean distance between two points in *n*-dimensional space represented by tuples of integers or floating-point values:
 18 | 
 19 | ```
 20 | template <typename Tup1, typename Tup2>
 21 | double euclidean_distance(Tup1 const &tup1, Tup2 const &tup2);
 22 | ```
 23 | 
 24 | Euclidean distance is defined by the following formula: `sqrt( (x[0] - y[0])^2 + ... + (x[n] - y[n])^2 )`, in other words the square root of the sum of square differences pair-wise between two points.
 25 | 
 26 | Usage example:
 27 | 
 28 | ```
 29 | auto distance = euclidean_distance(make_tuple(1, 2), make_tuple(4, 6));
 30 | // distance should be sqrt(3^2 + 4^2) = 5
 31 | ```
 32 | 
 33 | Hints:
 34 | 
 35 | * Use the `std::get<I>(tup)` function to obtain a tuple element at index `I`
 36 | * Note that the `std::get<I>` function works only if the parameter `I` is a compile-time constant; you can't just write a `for` loop that goes over all the elements in the tuple :-)
 37 | * The inner calculation can be recursive in terms of the current tuple element index with a base case 0
 38 | * Even if the tuples have a mix of integers and floating-point elements, do all the calculations with `double`s
 39 | * To find the number of elements in a tuple, use the `std::tuple_size` class template (e.g. if `Tup1` is a type of a tuple, `std::tuple_size<Tup1>::value` is the number of elements in the tuple)
 40 | 
 41 | > If you're really stuck, fill in the following skeleton that contains the core of the recursive solution:
 42 | >
 43 |     template <int I> struct helper {
 44 |       template <typename Tup1, typename Tup2>
 45 |       static double sum_squared_deltas(Tup1 const& tup1, Tup2 const& tup2) { ... }
 46 |     };
 47 |     template <> struct helper<0> {
 48 |       template <typename Tup1, typename Tup2>
 49 |       static double sum_squared_deltas(Tup1 const& tup1, Tup2 const& tup2) { ... }
 50 |     };
 51 | 
 52 | #### Lab 2: Compile-time computation -- `get<T>` for `tuple`s
 53 | 
 54 | C++ 14 introduces a very useful function for working with tuples: `get<T>`. Here's an example of how it works. Note that if the type doesn't appear exactly once in the tuple, the result should be a compilation error (not a runtime exception).
 55 | 
 56 | ```
 57 | auto tup = std::make_tuple(4.0, "Evelyn", 52);
 58 | std::get<double>(tup) = 3.0;
 59 | std::cout << std::get<int>(tup) << '\n';
 60 | ```
 61 | 
 62 | If you already have a standard library that supports C++ 14, good for you, but we’re still going to implement this facility ourselves. Here is the general sketch of a possible solution:
 63 | 
 64 | * Build a class template `count` that you can invoke as follows: `count<T, T1, T2, ..., Tn>::value` which returns the number of times `T` appears in the list of types that follow. This can be done by a simple specialization for `count<T>` and `count<T, Head, Tail...>`.
 65 | 
 66 | * Build a class template `find` that you can invoke as follows: `find<T, T1, T2, ..., Tn>::value` which returns the first index at which the type `T` appears in the list of types that follow. This can be done in a very similar way to `count`. (If `T` doesn't appear in the list of types specified, you can cause a compile-time error or simply return -1.)
 67 | 
 68 | Now, the `get<T>` function can use these helpers to call the standard `get<I>` function:
 69 | 
 70 | ```
 71 | template <typename T, typename... Ts>
 72 | T& get(std::tuple<Ts...>& tup) {
 73 |   static_assert(count<T, Ts...>::value == 1, "T must appear exactly once");
 74 |   return std::get<find<T, Ts...>::value>(tup);
 75 | }
 76 | ```
 77 | 
 78 | #### Lab 3: Trait and member detection -- `operator==` constraint for linear search
 79 | 
 80 | We would like to assert the necessary constraint when performing a linear search (such as what the STL `find` algorithm does). Specifically, the element we're looking for must be "equatable" (using `operator==`) to the elements in the input sequence.
 81 | 
 82 | Starting from the following code, add a static assertion that verifies the above constraint (in other words, checks that `val` can be compared to `*first` using `operator==`).
 83 | 
 84 | ```
 85 | template <typename It, typename T>
 86 | It linear_search(It first, It last, T const& val) {
 87 |   for (; first != last && !(val == *first); ++first)
 88 |       ;
 89 |   return first;
 90 | }
 91 | ```
 92 | 
 93 | There is no single correct solution, because there are many options. For example, you can try using the `void_t` approach, or the `constexpr`-function-based approach, to detect whether the necessary member exists.
 94 | 
 95 | > Note: Visual Studio 2015 doesn't have full support for expression SFINAE yet, which means your code might fail if you use the standard `void_t` approach. Try a different compiler, or Visual Studio 2015 Update 2.
 96 | 
 97 | #### Lab 4: Trait and member detection -- strings aren't containers, arrays are
 98 | 
 99 | The solution we built for detecting containers (`is_container`) is adequate for classic STL containers like `vector` and `map`, but it has two issues:
100 | 
101 | * It thinks `string` is a container, because it has a nested `::iterator` type. Although it is technically correct, we don't really want to treat strings as containers for the purpose of serialization or debug-printing.
102 | 
103 | * It thinks built-in arrays (like `int[5]`) are not containers, because they don't have a nested `::iterator` type. Again, for the purpose of serialization we would actually want to treat built-in arrays as containers.
104 | 
105 | Begin from the following `is_container` detector and fix the two problems above. Test your changes by using static assertions and also by using the `dump` method to print out a string and an array, and make sure you get the desired behavior.
106 | 
107 | ```
108 | // NOTE: Your standard library might already define void_t, in which case this declaration is not required
109 | template <typename T>
110 | using void_t = void;
111 | 
112 | template <typename T, typename = void>
113 | struct is_container : std::false_type {
114 | };
115 | 
116 | template <typename T>
117 | struct is_container<T, void_t<typename T::iterator>> : std::true_type {
118 | };
119 | 
120 | template <typename T>
121 | void dump(std::ostream& os, T const& val);
122 | 
123 | template <typename T>
124 | void dump(std::ostream& os, T const& val, std::true_type) {
125 |     os << "<<< begin container of type " << typeid(T).name() << " >>>\n";
126 |     for (auto const& elem : val) {
127 |         dump(os, elem);
128 |     }
129 |     os << "<<< end container >>>\n";
130 | }
131 | 
132 | template <typename T>
133 | void dump(std::ostream& os, T const& val, std::false_type) {
134 |     os << "plain value: " << val << '\n';
135 | }
136 | 
137 | template <typename T>
138 | void dump(std::ostream& os, T const& val) {
139 |     dump(os, val, std::integral_constant<bool, is_container<T>::value>{});
140 | }
141 | ```
142 | 
143 | > Hint: specialize `is_container` for strings and arrays. Specifically, strings are instantiations of the `std::basic_string<CharT, Traits, Allocator>` template, and arrays can be detected by specializing for their type and element count: `template <typename T, size_t N> struct is_container<T[N]> ...`.
144 | 
145 | #### Lab 5: Overload management with `enable_if`
146 | 
147 | A common pattern with library classes that want to eliminate unnecessary copies is a constructor that takes a *universal reference* (also known as *forwarding reference*). By using a universal reference and `std::forward`, rvalue objects can be moved while lvalue objects can be copied into their final destination inside the newly constructed instance. For example, consider the following `window` class, which is initialized with a toolbar:
148 | 
149 | ```
150 | class window {
151 |     toolbar toolbar_;
152 | public:
153 |     template <typename Toolbar>
154 |     window(Toolbar&& toolbar) : toolbar_{ std::forward<Toolbar>(toolbar) } {
155 |     }
156 |     window(window const& other) {
157 |         /* some copy construction */
158 |     }
159 |     window(window&& other) {
160 |         /* some move construction */
161 |     }
162 |     /* some additional methods */
163 | };
164 | ```
165 | 
166 | Perhaps surprisingly, there is a serious problem here that is known as *shadowing*. Namely, the template constructor can shadow the copy constructor. The following code does not compile:
167 | 
168 | ```
169 | toolbar tb;
170 | window w{ tb };
171 | window w2{ w };
172 | 
173 | error: excess elements in struct initializer
174 | window(Toolbar&& toolbar) : toolbar_{ std::forward<Toolbar>(toolbar) } {
175 |                                       ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
176 | ```
177 | 
178 | The culprit is that the compiler chooses the template overload because it can be specialized to form a better match: the `w` expression has type `window&`, which the template constructor can match exactly, whereas the copy constructor can only match after adding the `const` qualifier.
179 | 
180 | To solve this problem, the template constructor needs to be removed from the overload set when the type is `widget`. Use `enable_if` to do so.
181 | 
182 | > Hint: use `std::is_same`.
183 | 
184 | #### Lab 6: Integer sequences
185 | 
186 | Implement a function `array_to_tuple` that takes an array and returns a tuple that contains the same elements, in the same order.
187 | 
188 | > Hint: use an `index_sequence` and apply it to the array. Specifically, create a function that takes the array and a variadic `size_t... Ix` template parameter, and then expand `arr[Ix]...`.
189 | 
190 | Implement a function `invoke` that takes a function and a tuple, and returns the result of invoking that function with the tuple's elements as arguments.
191 | 
192 | > Hint: similarly to the previous task, use an `index_sequence` and expand `std::get<Ix>(tup)...`.
193 | 
194 | Revisit Lab 1 (Euclidean distance) and implement it using `index_sequence` instead of the manual recursive solution.
195 | 


--------------------------------------------------------------------------------