├── meta
    └── libraries.json
├── test
    ├── transform_test.hpp
    ├── join_test.hpp
    ├── zip_with_index_test.hpp
    ├── product_test.hpp
    ├── partition_test.hpp
    ├── take_test.hpp
    ├── erase_test.hpp
    ├── try_test.hpp
    ├── count_if_test.hpp
    ├── test.cpp
    ├── test_util.hpp
    ├── fold_right_test.hpp
    ├── reverse_test.hpp
    ├── contains_test.hpp
    ├── logic_test.hpp
    ├── find_if_test.hpp
    ├── fold_left_test.hpp
    ├── filter_test.hpp
    ├── tee_test.hpp
    └── sort_test.hpp
├── .gitignore
├── include
    └── boost
    │   ├── tmp
    │       ├── detail
    │       │   ├── capabilities.hpp
    │       │   ├── fusion_execute.hpp
    │       │   ├── fusion_rebind.hpp
    │       │   ├── dispatch.hpp
    │       │   └── expression.hpp
    │       ├── sequence
    │       │   ├── zip.hpp
    │       │   ├── swap.hpp
    │       │   ├── size.hpp
    │       │   ├── push_back.hpp
    │       │   ├── push_front.hpp
    │       │   ├── take.hpp
    │       │   ├── pop_front.hpp
    │       │   ├── erase.hpp
    │       │   ├── insert.hpp
    │       │   ├── container.hpp
    │       │   ├── unpack.hpp
    │       │   ├── zip_with_index.hpp
    │       │   ├── each.hpp
    │       │   ├── make_sequence.hpp
    │       │   ├── index.hpp
    │       │   ├── join.hpp
    │       │   ├── drop.hpp
    │       │   ├── rotate.hpp
    │       │   ├── tee.hpp
    │       │   └── reverse.hpp
    │       ├── algorithm
    │       │   ├── contains.hpp
    │       │   ├── partition.hpp
    │       │   ├── remove_if.hpp
    │       │   ├── replace_if.hpp
    │       │   ├── count_if.hpp
    │       │   ├── transform.hpp
    │       │   ├── product.hpp
    │       │   ├── filter.hpp
    │       │   ├── find_if.hpp
    │       │   ├── fold_right.hpp
    │       │   ├── sort.hpp
    │       │   └── fold_left.hpp
    │       ├── always.hpp
    │       ├── identity.hpp
    │       ├── vocabulary.hpp
    │       ├── comparison.hpp
    │       ├── try.hpp
    │       ├── lift.hpp
    │       ├── fusion
    │       │   ├── contains.hpp
    │       │   ├── find_if.hpp
    │       │   └── filter.hpp
    │       ├── fusion.hpp
    │       ├── if.hpp
    │       ├── call.hpp
    │       ├── pack.hpp
    │       └── logic.hpp
    │   └── tmp.hpp
├── .travis.yml
├── .clang-format
├── CMakeLists.txt
└── README.md


/meta/libraries.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "key": "mixin",
 3 |     "name": "Mixin",
 4 |     "authors": [
 5 |         "Odin Holmes"
 6 |     ],
 7 |     "maintainers": [
 8 |         "Odin Holmes <odinthenerd -at- gmail.com>"
 9 |     ],
10 |     "description": "A C++11 library for generic compositional component design.",
11 |     "category": [
12 |         "Metaprogramming"
13 |     ]
14 | }
15 | 


--------------------------------------------------------------------------------
/test/transform_test.hpp:
--------------------------------------------------------------------------------
 1 | #include "test_util.hpp"
 2 | 
 3 | namespace transform_test {
 4 | 	int run() {
 5 | 		using rhs = make_sequence_<identity_, transform_<listify_>>;
 6 | 		using lhs = make_sequence_<listify_>;
 7 | 		call_<make_sequence_<make_algo<lhs>>, extent>{} =
 8 | 		        call_<make_sequence_<make_algo<rhs>>, extent>{};
 9 | 
10 | 		return 0;
11 | 	}
12 | } // namespace transform_test
13 | 


--------------------------------------------------------------------------------
/test/join_test.hpp:
--------------------------------------------------------------------------------
 1 | #include "test_util.hpp"
 2 | #include "../include/boost/tmp/sequence/join.hpp"
 3 | 
 4 | namespace join_test {
 5 | 	int run() {
 6 | 		using make_listified_sequence = make_sequence_<listify_, push_front_<list_<>, join_<>>>;
 7 | 		call_<make_sequence_<make_algo<make_sequence_<>>>, extent>{} =
 8 | 		        call_<make_sequence_<make_algo<make_listified_sequence>>, extent>{};
 9 | 
10 | 		return 0;
11 | 	}
12 | } // namespace join_test


--------------------------------------------------------------------------------
/test/zip_with_index_test.hpp:
--------------------------------------------------------------------------------
 1 | #include "test_util.hpp"
 2 | 
 3 | namespace zip_with_index_test {
 4 | 	template <typename T>
 5 | 	using doubleify = list_<T, T>;
 6 | 
 7 | 	int run() {
 8 | 		using lhs = make_sequence_<lift_<doubleify>>;
 9 | 		using rhs = make_sequence_<identity_, zip_with_index_<>>;
10 | 		call_<make_sequence_<make_algo<lhs>>, extent>{} =
11 | 		        call_<make_sequence_<make_algo<rhs>>, extent>{};
12 | 
13 | 		return 0;
14 | 	}
15 | } // namespace zip_with_index_test
16 | 


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


--------------------------------------------------------------------------------
/include/boost/tmp/detail/capabilities.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef BOOST_TMP_CAPABILITIES_HPP_INCLUDED
 2 | #define BOOST_TMP_CAPABILITIES_HPP_INCLUDED
 3 | 
 4 | #if __clang_major__ == 3
 5 | #define BOOST_TMP_CLANG_ARITY_BUG
 6 | #endif
 7 | #if __cplusplus >= 201103L
 8 | #if __cplusplus >= 201402L
 9 | #define BOOST_TMP_CPP14
10 | #define BOOST_TMP_COMPLEX_CONSTEXPR constexpr
11 | #else
12 | #define BOOST_TMP_COMPLEX_CONSTEXPR
13 | #endif
14 | #else
15 | #error "__cplusplus must be > 201103L (the value of C++11)"
16 | #endif
17 | 
18 | #endif


--------------------------------------------------------------------------------
/test/product_test.hpp:
--------------------------------------------------------------------------------
 1 | #include "test_util.hpp"
 2 | #include "../include/boost/tmp/algorithm/product.hpp"
 3 | 
 4 | namespace product_test {
 5 | 	template <int I>
 6 | 	struct x {
 7 | 		static constexpr int value = I;
 8 | 	};
 9 | 
10 | 	using xl0 = list_<x<1>, x<2>, x<3>, x<4>, x<5>, x<6>, x<7>, x<8>, x<9>, x<10>>;
11 | 	using xr0 = list_<x<1>, x<2>, x<3>, x<4>, x<5>, x<6>, x<7>, x<8>, x<9>, x<10>>;
12 | 
13 | 	using result0 = call_<product_<>, xl0, xr0>;
14 | 	int run() {
15 | 
16 | 		return 0;
17 | 	}
18 | } // namespace product_test


--------------------------------------------------------------------------------
/include/boost/tmp/detail/fusion_execute.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef BOOST_TMP_FUSION_EXECUTE_HPP_INCLUDED
 2 | #define BOOST_TMP_FUSION_EXECUTE_HPP_INCLUDED
 3 | 
 4 | //  Copyright 2018 Odin Holmes.
 5 | //
 6 | //  Distributed under the Boost Software License, Version 1.0.
 7 | //
 8 | //  See accompanying file LICENSE_1_0.txt or copy at
 9 | //  http://www.boost.org/LICENSE_1_0.txt
10 | #include "../vocabulary.hpp"
11 | 
12 | namespace boost {
13 | 	namespace tmp {
14 | 		namespace fusion {}
15 | 	} // namespace tmp
16 | } // namespace boost
17 | 
18 | #endif


--------------------------------------------------------------------------------
/test/partition_test.hpp:
--------------------------------------------------------------------------------
 1 | #include "test_util.hpp"
 2 | #include "../include/boost/tmp/algorithm/partition.hpp"
 3 | 
 4 | namespace partition_test {
 5 | 	template <int I>
 6 | 	struct x {
 7 | 		static constexpr int value = I;
 8 | 	};
 9 | 
10 | 	using xs0 = list_<x<1>, x<2>, x<3>, x<4>, x<5>, x<6>, x<7>, x<8>, x<9>, x<10>>;
11 | 
12 | 	template <typename T>
13 | 	using more_than_5 = bool_<(T::value > 5)>;
14 | 
15 | 	using result0 = call_<unpack_<partition_<lift_<more_than_5>>>, xs0>;
16 | 	int run() {
17 | 
18 | 		return 0;
19 | 	}
20 | } // namespace partition_test


--------------------------------------------------------------------------------
/test/take_test.hpp:
--------------------------------------------------------------------------------
 1 | #include "test_util.hpp"
 2 | #include "../include/boost/tmp/sequence/take.hpp"
 3 | #include "../include/boost/tmp/vocabulary.hpp"
 4 | namespace take_test {
 5 | 	template <int>
 6 | 	struct x;
 7 | 
 8 | 	using xs0 = list_<x<1>, x<2>, x<3>, x<4>, x<5>, x<6>, x<7>, x<8>, x<9>, x<10>>;
 9 | 
10 | 	using result0 = call_<unpack_<take_<uint_<0>>>, xs0>;
11 | 	using result1 = call_<unpack_<take_<uint_<1>>>, xs0>;
12 | 	using result2 = call_<unpack_<take_<uint_<9>>>, xs0>;
13 | 
14 | 	int run() {
15 | 
16 | 		return 0;
17 | 	}
18 | } // namespace take_test


--------------------------------------------------------------------------------
/test/erase_test.hpp:
--------------------------------------------------------------------------------
 1 | #include "test_util.hpp"
 2 | #include "../include/boost/tmp/sequence/erase.hpp"
 3 | #include "../include/boost/tmp/vocabulary.hpp"
 4 | namespace erase_test {
 5 | 	template <int>
 6 | 	struct x;
 7 | 
 8 | 	using xs0 = list_<x<1>, x<2>, x<3>, x<4>, x<5>, x<6>, x<7>, x<8>, x<9>, x<10>>;
 9 | 
10 | 	using result0 = call_<unpack_<erase_<uint_<0>>>, xs0>;
11 | 	using result1 = call_<unpack_<erase_<uint_<1>>>, xs0>;
12 | 	using result2 = call_<unpack_<erase_<uint_<9>>>, xs0>;
13 | 
14 | 	int run() {
15 | 
16 | 		return 0;
17 | 	}
18 | } // namespace erase_test


--------------------------------------------------------------------------------
/test/try_test.hpp:
--------------------------------------------------------------------------------
 1 | #include "test_util.hpp"
 2 | #include "../include/boost/tmp/try.hpp"
 3 | 
 4 | namespace try_test {
 5 | 	template <typename T>
 6 | 	using call_type = typename T::type;
 7 | 
 8 | 	struct has_type {
 9 | 		using type = int;
10 | 	};
11 | 	int run() {
12 | 		nothing_{}   = call_<try_<call_type>, int>{}; // should SFINAE, int has no ::type
13 | 		list_<int>{} = list_<call_<try_<call_type>, has_type>>{}; // should not SFINAE
14 | 		list_<int>{} = call_<try_<call_type, listify_>, has_type>{}; // test the continuation
15 | 
16 | 		return 0;
17 | 	}
18 | } // namespace try_test
19 | 


--------------------------------------------------------------------------------
/include/boost/tmp/sequence/zip.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef BOOST_TMP_ZIP_HPP_INCLUDED
 2 | #define BOOST_TMP_ZIP_HPP_INCLUDED
 3 | 
 4 | //  Copyright 2018 Odin Holmes.
 5 | //
 6 | //  Distributed under the Boost Software License, Version 1.0.
 7 | //
 8 | //  See accompanying file LICENSE_1_0.txt or copy at
 9 | //  http://www.boost.org/LICENSE_1_0.txt
10 | 
11 | #include <utility>
12 | #include "../call.hpp"
13 | #include "../vocabulary.hpp"
14 | 
15 | namespace boost {
16 | 	namespace tmp {
17 | 		template <typename F, typename C = listify_>
18 | 		struct zip_ {};
19 | 		namespace detail {
20 | 			// TODO add impl
21 | 		}
22 | 	} // namespace tmp
23 | } // namespace boost
24 | 
25 | #endif
26 | 


--------------------------------------------------------------------------------
/test/count_if_test.hpp:
--------------------------------------------------------------------------------
 1 | #include "test_util.hpp"
 2 | #include "../include/boost/tmp/algorithm/count_if.hpp"
 3 | 
 4 | namespace count_if_test {
 5 | 	template <typename T>
 6 | 	using divide_by_two_celing = int_<((T::value >> 1) + (T::value & 1))>;
 7 | 	template <typename T>
 8 | 	using multiply_by_2 = uint_<(T::value << 1)>;
 9 | 
10 | 	template <typename T>
11 | 	using is_even = bool_<(T::value % 2 == 0)>;
12 | 	int run() {
13 | 
14 | 		uint_<0>{} = call_<count_if_<lift_<is_even>>, int_<1>>{};
15 | 		uint_<1>{} = call_<count_if_<lift_<is_even>>, int_<2>>{};
16 | 		uint_<0>{} = call_<count_if_<lift_<is_even>>, int_<1>, int_<1>, int_<1>>{};
17 | 
18 | 		return 0;
19 | 	}
20 | } // namespace count_if_test


--------------------------------------------------------------------------------
/test/test.cpp:
--------------------------------------------------------------------------------
 1 | #include "contains_test.hpp"
 2 | #include "count_if_test.hpp"
 3 | #include "erase_test.hpp"
 4 | #include "filter_test.hpp"
 5 | #include "tee_test.hpp"
 6 | #include "find_if_test.hpp"
 7 | #include "fold_left_test.hpp"
 8 | #include "fold_right_test.hpp"
 9 | #include "join_test.hpp"
10 | #include "logic_test.hpp"
11 | #include "partition_test.hpp"
12 | #include "product_test.hpp"
13 | #include "reverse_test.hpp"
14 | #include "sort_test.hpp"
15 | #include "take_test.hpp"
16 | #include "transform_test.hpp"
17 | #include "try_test.hpp"
18 | #include "zip_with_index_test.hpp"
19 | 
20 | int main() {
21 | 	return join_test::run() || transform_test::run() || fold_left_test::run() ||
22 | 	       zip_with_index_test::run();
23 | }
24 | 


--------------------------------------------------------------------------------
/test/test_util.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef BOOST_TMP_TEST_UTIL_HPP_INCLUDED
 2 | #define BOOST_TMP_TEST_UTIL_HPP_INCLUDED
 3 | 
 4 | //  Copyright 2018 Odin Holmes.
 5 | //
 6 | //  Distributed under the Boost Software License, Version 1.0.
 7 | //
 8 | //  See accompanying file LICENSE_1_0.txt or copy at
 9 | //  http://www.boost.org/LICENSE_1_0.txt
10 | 
11 | #include "../include/boost/tmp/call.hpp"
12 | #include "../include/boost/tmp/sequence/make_sequence.hpp"
13 | #include "../include/boost/tmp/sequence/push_front.hpp"
14 | #include "../include/boost/tmp/sequence/tee.hpp"
15 | 
16 | using namespace boost::tmp;
17 | template <typename T>
18 | using make_algo = tee_<always_<T>, identity_, call_f_<>>;
19 | 
20 | using extent = uint_<50>;
21 | 
22 | #endif
23 | 


--------------------------------------------------------------------------------
/include/boost/tmp/algorithm/contains.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef BOOST_TMP_CONTAINS_HPP_INCLUDED
 2 | #define BOOST_TMP_CONTAINS_HPP_INCLUDED
 3 | 
 4 | //  Copyright 2018 Odin Holmes.
 5 | //
 6 | //  Distributed under the Boost Software License, Version 1.0.
 7 | //
 8 | //  See accompanying file LICENSE_1_0.txt or copy at
 9 | //  http://www.boost.org/LICENSE_1_0.txt
10 | 
11 | #include "../identity.hpp"
12 | #include "../logic.hpp"
13 | 
14 | namespace boost {
15 | 	namespace tmp {
16 | 		template <typename V, typename C = identity_>
17 | 		struct contains_;
18 | 
19 | 		namespace detail {
20 | 			template <unsigned N, typename V, typename C>
21 | 			struct dispatch<N, contains_<V, C>> : dispatch<N, or_<is_<V>, C>> {};
22 | 		} // namespace detail
23 | 	} // namespace tmp
24 | } // namespace boost
25 | 
26 | #endif


--------------------------------------------------------------------------------
/include/boost/tmp/sequence/swap.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef BOOST_TMP_SWAP_HPP_INCLUDED
 2 | #define BOOST_TMP_SWAP_HPP_INCLUDED
 3 | 
 4 | //  Copyright 2018 Odin Holmes.
 5 | //
 6 | //  Distributed under the Boost Software License, Version 1.0.
 7 | //
 8 | //  See accompanying file LICENSE_1_0.txt or copy at
 9 | //  http://www.boost.org/LICENSE_1_0.txt
10 | 
11 | #include "../identity.hpp"
12 | #include "../vocabulary.hpp"
13 | namespace boost {
14 | 	namespace tmp {
15 | 		template <typename C = listify_>
16 | 		struct swap_ {};
17 | 		namespace detail {
18 | 			template <typename C>
19 | 			struct dispatch<2, swap_<C>> {
20 | 				template <typename T, typename U>
21 | 				using f = typename dispatch<2, C>::template f<U, T>;
22 | 			};
23 | 		} // namespace detail
24 | 	} // namespace tmp
25 | } // namespace boost
26 | 
27 | #endif
28 | 


--------------------------------------------------------------------------------
/include/boost/tmp/detail/fusion_rebind.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef BOOST_TMP_FUSION_REBIND_HPP_INCLUDED
 2 | #define BOOST_TMP_FUSION_REBIND_HPP_INCLUDED
 3 | 
 4 | //  Copyright 2018 Odin Holmes.
 5 | //
 6 | //  Distributed under the Boost Software License, Version 1.0.
 7 | //
 8 | //  See accompanying file LICENSE_1_0.txt or copy at
 9 | //  http://www.boost.org/LICENSE_1_0.txt
10 | #include "capabilities.hpp"
11 | namespace boost {
12 | 	namespace tmp {
13 | #ifdef BOOST_TMP_CPP14
14 | 		namespace fusion {
15 | 			// to make a metafunction fusion capable this traits must be specialized
16 | 			// with the rebound version of the metafunction to be used in fusion context
17 | 			template <typename T>
18 | 			struct rebind;
19 | 		} // namespace fusion
20 | #endif
21 | 	} // namespace tmp
22 | } // namespace boost
23 | 
24 | #endif


--------------------------------------------------------------------------------
/include/boost/tmp/sequence/size.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef BOOST_TMP_SIZE_HPP_INCLUDED
 2 | #define BOOST_TMP_SIZE_HPP_INCLUDED
 3 | 
 4 | //  Copyright 2018 Odin Holmes.
 5 | //
 6 | //  Distributed under the Boost Software License, Version 1.0.
 7 | //
 8 | //  See accompanying file LICENSE_1_0.txt or copy at
 9 | //  http://www.boost.org/LICENSE_1_0.txt
10 | 
11 | #include "../identity.hpp"
12 | #include "../vocabulary.hpp"
13 | namespace boost {
14 | 	namespace tmp {
15 | 		template <typename C = identity_>
16 | 		struct size_ {};
17 | 		namespace detail {
18 | 			template <unsigned N, typename C>
19 | 			struct dispatch<N, size_<C>> {
20 | 				template <typename... Ls>
21 | 				using f = typename dispatch<1, C>::template f<uint_<sizeof...(Ls)>>;
22 | 			};
23 | 		} // namespace detail
24 | 	} // namespace tmp
25 | } // namespace boost
26 | 
27 | #endif
28 | 


--------------------------------------------------------------------------------
/include/boost/tmp/always.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef BOOST_TMP_ALWAYS_HPP_INCLUDED
 2 | #define BOOST_TMP_ALWAYS_HPP_INCLUDED
 3 | 
 4 | //  Copyright 2018 Odin Holmes.
 5 | //
 6 | //  Distributed under the Boost Software License, Version 1.0.
 7 | //
 8 | //  See accompanying file LICENSE_1_0.txt or copy at
 9 | //  http://www.boost.org/LICENSE_1_0.txt
10 | 
11 | #include "detail/dispatch.hpp"
12 | #include "identity.hpp"
13 | 
14 | namespace boost {
15 | 	namespace tmp {
16 | 		template <typename T, typename C = identity_>
17 | 		struct always_ {};
18 | 
19 | 		namespace detail {
20 | 			template <unsigned N, typename T, typename C>
21 | 			struct dispatch<N, always_<T, C>> {
22 | 				template <typename...>
23 | 				using f = typename dispatch<1, C>::template f<T>;
24 | 			};
25 | 		} // namespace detail
26 | 	} // namespace tmp
27 | } // namespace boost
28 | #endif
29 | 


--------------------------------------------------------------------------------
/test/fold_right_test.hpp:
--------------------------------------------------------------------------------
 1 | #include "test_util.hpp"
 2 | #include "../include/boost/tmp/algorithm/fold_right.hpp"
 3 | 
 4 | namespace fold_right_test {
 5 | 	template <typename T, typename U>
 6 | 	using add = uint_<(T::value + U::value)>;
 7 | 	int run() {
 8 | 		uint_<1>{}  = call_<fold_right_<lift_<add>>, uint_<1>>{};
 9 | 		uint_<3>{}  = call_<fold_right_<lift_<add>>, uint_<1>, uint_<2>>{};
10 | 		uint_<6>{}  = call_<fold_right_<lift_<add>>, uint_<1>, uint_<2>, uint_<3>>{};
11 | 		uint_<10>{} = call_<fold_right_<lift_<add>>, uint_<1>, uint_<2>, uint_<3>, uint_<4>>{};
12 | 		uint_<20>{} = call_<fold_right_<lift_<add>>, uint_<1>, uint_<1>, uint_<1>, uint_<1>,
13 | 		                    uint_<1>, uint_<1>, uint_<1>, uint_<1>, uint_<1>, uint_<1>, uint_<1>,
14 | 		                    uint_<2>, uint_<3>, uint_<4>>{};
15 | 		return 0;
16 | 	}
17 | } // namespace fold_right_test
18 | 


--------------------------------------------------------------------------------
/include/boost/tmp/algorithm/partition.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef BOOST_TMP_PARTITION_HPP_INCLUDED
 2 | #define BOOST_TMP_PARTITION_HPP_INCLUDED
 3 | 
 4 | //  Copyright 2018 Odin Holmes.
 5 | //
 6 | //  Distributed under the Boost Software License, Version 1.0.
 7 | //
 8 | //  See accompanying file LICENSE_1_0.txt or copy at
 9 | //  http://www.boost.org/LICENSE_1_0.txt
10 | 
11 | #include "filter.hpp"
12 | #include "remove_if.hpp"
13 | #include "../call.hpp"
14 | #include "../sequence/tee.hpp"
15 | #include "../vocabulary.hpp"
16 | 
17 | namespace boost {
18 | 	namespace tmp {
19 | 		template <typename F, typename C = listify_>
20 | 		struct partition_ {};
21 | 
22 | 		namespace detail {
23 | 			template <unsigned N, typename F, typename C>
24 | 			struct dispatch<N, partition_<F, C>> : dispatch<N, tee_<filter_<F>, remove_if_<F>, C>> {
25 | 			};
26 | 		} // namespace detail
27 | 	} // namespace tmp
28 | } // namespace boost
29 | 
30 | #endif


--------------------------------------------------------------------------------
/include/boost/tmp/identity.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef BOOST_TMP_IDENTITY_HPP_INCLUDED
 2 | #define BOOST_TMP_IDENTITY_HPP_INCLUDED
 3 | 
 4 | //  Copyright 2018 Odin Holmes.
 5 | //
 6 | //  Distributed under the Boost Software License, Version 1.0.
 7 | //
 8 | //  See accompanying file LICENSE_1_0.txt or copy at
 9 | //  http://www.boost.org/LICENSE_1_0.txt
10 | 
11 | #include "detail/capabilities.hpp"
12 | #include "detail/dispatch.hpp"
13 | #include "detail/fusion_rebind.hpp"
14 | namespace boost {
15 | 	namespace tmp {
16 | 		struct identity_ {};
17 | #ifdef BOOST_TMP_CPP14
18 | 		namespace fusion {
19 | 			template <>
20 | 			struct rebind<identity_> {
21 | 				using type = identity_;
22 | 			};
23 | 		} // namespace fusion
24 | #endif
25 | 		namespace detail {
26 | 			template <>
27 | 			struct dispatch<1, identity_> {
28 | 				template <typename T>
29 | 				using f = T;
30 | 			};
31 | 		} // namespace detail
32 | 	} // namespace tmp
33 | } // namespace boost
34 | #endif
35 | 


--------------------------------------------------------------------------------
/include/boost/tmp/sequence/push_back.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef BOOST_TMP_PUSH_BACK_HPP_INCLUDED
 2 | #define BOOST_TMP_PUSH_BACK_HPP_INCLUDED
 3 | 
 4 | //  Copyright 2018 Odin Holmes.
 5 | //
 6 | //  Distributed under the Boost Software License, Version 1.0.
 7 | //
 8 | //  See accompanying file LICENSE_1_0.txt or copy at
 9 | //  http://www.boost.org/LICENSE_1_0.txt
10 | 
11 | #include "../identity.hpp"
12 | #include "../vocabulary.hpp"
13 | namespace boost {
14 | 	namespace tmp {
15 | 		template <typename T, typename C = listify_>
16 | 		struct push_back_ {};
17 | 		namespace detail {
18 | 			template <unsigned N, typename T, typename C>
19 | 			struct dispatch<N, push_back_<T, C>> {
20 | 				template <typename... Ts>
21 | 				using f = typename dispatch<find_dispatch(sizeof...(Ts) + 1), C>::template f<Ts...,
22 | 				                                                                             T>;
23 | 			};
24 | 		} // namespace detail
25 | 	} // namespace tmp
26 | } // namespace boost
27 | 
28 | #endif
29 | 


--------------------------------------------------------------------------------
/include/boost/tmp/sequence/push_front.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef BOOST_TMP_PUSH_FRONT_HPP_INCLUDED
 2 | #define BOOST_TMP_PUSH_FRONT_HPP_INCLUDED
 3 | 
 4 | //  Copyright 2018 Odin Holmes.
 5 | //
 6 | //  Distributed under the Boost Software License, Version 1.0.
 7 | //
 8 | //  See accompanying file LICENSE_1_0.txt or copy at
 9 | //  http://www.boost.org/LICENSE_1_0.txt
10 | 
11 | #include "../identity.hpp"
12 | #include "../vocabulary.hpp"
13 | namespace boost {
14 | 	namespace tmp {
15 | 		template <typename T, typename C = listify_>
16 | 		struct push_front_ {};
17 | 		namespace detail {
18 | 			template <unsigned N, typename T, typename C>
19 | 			struct dispatch<N, push_front_<T, C>> {
20 | 				template <typename... Ts>
21 | 				using f = typename dispatch<find_dispatch(sizeof...(Ts) + 1), C>::template f<T,
22 | 				                                                                             Ts...>;
23 | 			};
24 | 		} // namespace detail
25 | 	} // namespace tmp
26 | } // namespace boost
27 | 
28 | #endif
29 | 


--------------------------------------------------------------------------------
/include/boost/tmp/sequence/take.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef BOOST_TMP_TAKE_HPP_INCLUDED
 2 | #define BOOST_TMP_TAKE_HPP_INCLUDED
 3 | 
 4 | //  Copyright 2018 Odin Holmes.
 5 | //
 6 | //  Distributed under the Boost Software License, Version 1.0.
 7 | //
 8 | //  See accompanying file LICENSE_1_0.txt or copy at
 9 | //  http://www.boost.org/LICENSE_1_0.txt
10 | 
11 | #include "drop.hpp"
12 | #include "rotate.hpp"
13 | #include "../vocabulary.hpp"
14 | 
15 | namespace boost {
16 | 	namespace tmp {
17 | 		template <typename N = uint_<0>, typename C = listify_>
18 | 		struct take_ {};
19 | 
20 | 		namespace detail {
21 | 			template <unsigned N, typename P, typename C>
22 | 			struct dispatch<N, take_<P, C>> {
23 | 				template <typename... Ts>
24 | 				using f = typename dispatch<
25 | 				        find_dispatch(sizeof...(Ts)),
26 | 				        rotate_<P, drop_<uint_<(sizeof...(Ts) - P::value)>, C>>>::template f<Ts...>;
27 | 			};
28 | 		} // namespace detail
29 | 	} // namespace tmp
30 | } // namespace boost
31 | 
32 | #endif


--------------------------------------------------------------------------------
/include/boost/tmp/algorithm/remove_if.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef BOOST_TMP_REMOVE_IF_HPP_INCLUDED
 2 | #define BOOST_TMP_REMOVE_IF_HPP_INCLUDED
 3 | 
 4 | //  Copyright 2018 Odin Holmes.
 5 | //
 6 | //  Distributed under the Boost Software License, Version 1.0.
 7 | //
 8 | //  See accompanying file LICENSE_1_0.txt or copy at
 9 | //  http://www.boost.org/LICENSE_1_0.txt
10 | 
11 | #include "transform.hpp"
12 | #include "../always.hpp"
13 | #include "../call.hpp"
14 | #include "../detail/dispatch.hpp"
15 | #include "../if.hpp"
16 | #include "../sequence/join.hpp"
17 | #include "../vocabulary.hpp"
18 | 
19 | namespace boost {
20 | 	namespace tmp {
21 | 		template <typename F, typename C = listify_>
22 | 		struct remove_if_ {};
23 | 		namespace detail {
24 | 			template <unsigned N, typename F, typename C>
25 | 			struct dispatch<N, remove_if_<F, C>>
26 | 			    : dispatch<N, transform_<if_<F, always_<list_<>>, listify_>, join_<C>>> {};
27 | 		} // namespace detail
28 | 	} // namespace tmp
29 | } // namespace boost
30 | 
31 | #endif


--------------------------------------------------------------------------------
/test/reverse_test.hpp:
--------------------------------------------------------------------------------
 1 | #include "test_util.hpp"
 2 | #include "../include/boost/tmp/sequence/reverse.hpp"
 3 | #
 4 | 
 5 | namespace reverse_test {
 6 | 	int run() {
 7 | 		using rhs = make_sequence_<identity_, reverse_<reverse_<>>>;
 8 | 		using lhs = make_sequence_<>;
 9 | 		call_<make_sequence_<make_algo<lhs>>, extent>{} =
10 | 		        call_<make_sequence_<make_algo<rhs>>, extent>{};
11 | 
12 | 		list_<uint_<0>>{} = call_<make_sequence_<identity_, reverse_<>>, uint_<1>>{};
13 | 
14 | 		list_<uint_<1>, uint_<0>>{} = call_<make_sequence_<identity_, reverse_<>>, uint_<2>>{};
15 | 
16 | 		list_<uint_<2>, uint_<1>, uint_<0>>{} =
17 | 		        call_<make_sequence_<identity_, reverse_<>>, uint_<3>>{};
18 | 
19 | 		list_<uint_<3>, uint_<2>, uint_<1>, uint_<0>>{} =
20 | 		        call_<make_sequence_<identity_, reverse_<>>, uint_<4>>{};
21 | 
22 | 		list_<uint_<4>, uint_<3>, uint_<2>, uint_<1>, uint_<0>>{} =
23 | 		        call_<make_sequence_<identity_, reverse_<>>, uint_<5>>{};
24 | 
25 | 		return 0;
26 | 	}
27 | } // namespace reverse_test
28 | 


--------------------------------------------------------------------------------
/include/boost/tmp/vocabulary.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef BOOST_TMP_VOCABULARY_HPP_INCLUDED
 2 | #define BOOST_TMP_VOCABULARY_HPP_INCLUDED
 3 | 
 4 | //  Copyright 2018 Odin Holmes.
 5 | //
 6 | //  Distributed under the Boost Software License, Version 1.0.
 7 | //
 8 | //  See accompanying file LICENSE_1_0.txt or copy at
 9 | //  http://www.boost.org/LICENSE_1_0.txt
10 | 
11 | #include "always.hpp"
12 | #include "lift.hpp"
13 | 
14 | namespace boost {
15 | 	namespace tmp {
16 | 		template <typename... Ts>
17 | 		struct list_ {};
18 | 
19 | 		using listify_ = lift_<list_>;
20 | 
21 | 		template <unsigned long long V>
22 | 		struct uint_ {
23 | 			static constexpr unsigned long long value = V;
24 | 		};
25 | 		template <long long I>
26 | 		struct int_ {
27 | 			static constexpr long long value = I;
28 | 		};
29 | 		template <bool B>
30 | 		struct bool_ {
31 | 			static constexpr bool value = B;
32 | 		};
33 | 
34 | 		using true_  = bool_<true>;
35 | 		using false_ = bool_<false>;
36 | 
37 | 		struct nothing_ {};
38 | 	} // namespace tmp
39 | } // namespace boost
40 | #endif
41 | 


--------------------------------------------------------------------------------
/include/boost/tmp/algorithm/replace_if.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef BOOST_TMP_REPLACE_IF_HPP_INCLUDED
 2 | #define BOOST_TMP_REPLACE_IF_HPP_INCLUDED
 3 | 
 4 | //  Copyright 2018 Odin Holmes.
 5 | //
 6 | //  Distributed under the Boost Software License, Version 1.0.
 7 | //
 8 | //  See accompanying file LICENSE_1_0.txt or copy at
 9 | //  http://www.boost.org/LICENSE_1_0.txt
10 | 
11 | #include "transform.hpp"
12 | #include "../always.hpp"
13 | #include "../call.hpp"
14 | #include "../detail/dispatch.hpp"
15 | #include "../if.hpp"
16 | #include "../sequence/join.hpp"
17 | #include "../vocabulary.hpp"
18 | 
19 | namespace boost {
20 | 	namespace tmp {
21 | 		template <typename Input, typename F, typename C = listify_>
22 | 		struct replace_if_ {};
23 | 		namespace detail {
24 | 			template <unsigned N, typename Input, typename F, typename C>
25 | 			struct dispatch<N, replace_if_<Input, F, C>>
26 | 			    : dispatch<N, transform_<if_<F, always_<Input>, identity_>, C>> {};
27 | 		} // namespace detail
28 | 	} // namespace tmp
29 | } // namespace boost
30 | 
31 | #endif


--------------------------------------------------------------------------------
/include/boost/tmp/sequence/pop_front.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef BOOST_TMP_POP_FRONT_HPP_INCLUDED
 2 | #define BOOST_TMP_POP_FRONT_HPP_INCLUDED
 3 | 
 4 | //  Copyright 2018 Odin Holmes.
 5 | //
 6 | //  Distributed under the Boost Software License, Version 1.0.
 7 | //
 8 | //  See accompanying file LICENSE_1_0.txt or copy at
 9 | //  http://www.boost.org/LICENSE_1_0.txt
10 | 
11 | #include "../identity.hpp"
12 | #include "../vocabulary.hpp"
13 | namespace boost {
14 | 	namespace tmp {
15 | 		template <typename C = listify_>
16 | 		struct pop_front_ {};
17 | 		namespace detail {
18 | 			template <unsigned N, typename C>
19 | 			struct dispatch<N, pop_front_<C>> {
20 | 				template <typename T, typename... Ts>
21 | 				using f = typename dispatch<find_dispatch(sizeof...(Ts)), C>::template f<Ts...>;
22 | 			};
23 | 			template <typename C>
24 | 			struct dispatch<0, pop_front_<C>> {
25 | 				template <typename... Ts>
26 | 				using f = typename dispatch<1, C>::template f<nothing_>;
27 | 			};
28 | 		} // namespace detail
29 | 	} // namespace tmp
30 | } // namespace boost
31 | 
32 | #endif
33 | 


--------------------------------------------------------------------------------
/include/boost/tmp/algorithm/count_if.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef BOOST_TMP_COUNT_IF_HPP_INCLUDED
 2 | #define BOOST_TMP_COUNT_IF_HPP_INCLUDED
 3 | 
 4 | //  Copyright 2018 Odin Holmes.
 5 | //
 6 | //  Distributed under the Boost Software License, Version 1.0.
 7 | //
 8 | //  See accompanying file LICENSE_1_0.txt or copy at
 9 | //  http://www.boost.org/LICENSE_1_0.txt
10 | 
11 | #include "transform.hpp"
12 | #include "../call.hpp"
13 | #include "../detail/dispatch.hpp"
14 | #include "../if.hpp"
15 | #include "../sequence/join.hpp"
16 | #include "../sequence/size.hpp"
17 | #include "../vocabulary.hpp"
18 | 
19 | namespace boost {
20 | 	namespace tmp {
21 | 		template <typename F, typename C = identity_>
22 | 		struct count_if_ {};
23 | 		namespace detail {
24 | 			template <unsigned N, typename F, typename C>
25 | 			struct dispatch<N, count_if_<F, C>>
26 | 			    : dispatch<N, transform_<if_<F, always_<list_<void>>, always_<list_<>>>,
27 | 			                             join_<size_<C>>>> {};
28 | 		} // namespace detail
29 | 	} // namespace tmp
30 | } // namespace boost
31 | 
32 | #endif


--------------------------------------------------------------------------------
/test/contains_test.hpp:
--------------------------------------------------------------------------------
 1 | #include "test_util.hpp"
 2 | #include "../include/boost/tmp/algorithm/contains.hpp"
 3 | #include "../include/boost/tmp/comparison.hpp"
 4 | namespace contains_test {
 5 | 	template <int>
 6 | 	struct x;
 7 | 
 8 | 	using xs0 = list_<x<1>, x<2>, x<3>, x<4>, x<5>, x<6>, x<7>, x<8>, x<9>, x<10>>;
 9 | 
10 | 	using result0 = call_<unpack_<contains_<is_<x<0>>>>, xs0>;
11 | 	using result1 = call_<unpack_<contains_<is_<x<1>>>>, xs0>;
12 | 	using result2 = call_<unpack_<contains_<is_<x<5>>>>, xs0>;
13 | 	using result3 = call_<unpack_<contains_<is_<x<10>>>>, xs0>;
14 | 
15 | 	// fusion
16 | 	/*
17 | #ifdef BOOST_TMP_CPP14
18 | 	int i                 = 1;
19 | 	    true_ ll = pack_(false, 'a', i, 2, true) >>=
20 | 	            contains_<int>{} |
21 | 	            [](auto l) { return l; };
22 | 	    auto lll = pack_(false, 'a', i, 2, true) >>=
23 | 	            contains_<lift_<std::remove_reference_t, is_<long long>>>{} |
24 | 	            [](auto l) { return l; };
25 | #endif
26 | */
27 | 	int run() {
28 | 
29 | 		return 0;
30 | 	}
31 | } // namespace contains_test


--------------------------------------------------------------------------------
/include/boost/tmp/comparison.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef BOOST_TMP_COMPARISON_HPP_INCLUDED
 2 | #define BOOST_TMP_COMPARISON_HPP_INCLUDED
 3 | 
 4 | //  Copyright 2018 Odin Holmes.
 5 | //
 6 | //  Distributed under the Boost Software License, Version 1.0.
 7 | //
 8 | //  See accompanying file LICENSE_1_0.txt or copy at
 9 | //  http://www.boost.org/LICENSE_1_0.txt
10 | 
11 | #include <type_traits>
12 | #include "vocabulary.hpp"
13 | 
14 | namespace boost {
15 | 	namespace tmp {
16 | 		template <typename P, typename C = identity_>
17 | 		struct is_ {};
18 | 
19 | 		template <typename C = identity_>
20 | 		struct less_ {};
21 | 
22 | 		namespace detail {
23 | 			template <typename P, typename C>
24 | 			struct dispatch<1, is_<P, C>> {
25 | 				template <typename T>
26 | 				using f = typename dispatch<1, C>::template f<bool_<std::is_same<P, T>::value>>;
27 | 			};
28 | 
29 | 			template <typename C>
30 | 			struct dispatch<2, less_<C>> {
31 | 				template <typename T, typename U>
32 | 				using f = typename dispatch<1, C>::template f < bool_<T::value<U::value>>;
33 | 			};
34 | 		} // namespace detail
35 | 	} // namespace tmp
36 | } // namespace boost
37 | #endif
38 | 


--------------------------------------------------------------------------------
/test/logic_test.hpp:
--------------------------------------------------------------------------------
 1 | #include <memory>
 2 | #include "test_util.hpp"
 3 | #include "../include/boost/tmp/logic.hpp"
 4 | 
 5 | namespace logic_test {
 6 | 	template <typename T>
 7 | 	using is_even = bool_<(T::value % 2 == 0)>;
 8 | 	int run() {
 9 | 
10 | 		bool_<false>{} = call_<and_<lift_<is_even>>, int_<1>, int_<1>, int_<1>, int_<1>, int_<1>,
11 | 		                       int_<1>, int_<1>, int_<1>, int_<1>>{};
12 | 
13 | 		bool_<false>{} = call_<and_<lift_<is_even>>, int_<2>, int_<1>, int_<1>, int_<1>, int_<1>,
14 | 		                       int_<1>, int_<1>, int_<1>, int_<2>>{};
15 | 
16 | 		bool_<true>{} = call_<and_<lift_<is_even>>, int_<2>, int_<2>, int_<2>>{};
17 | 
18 | 		bool_<false>{} = call_<or_<lift_<is_even>>, int_<1>, int_<1>, int_<1>, int_<1>, int_<1>,
19 | 		                       int_<1>, int_<1>, int_<1>, int_<1>>{};
20 | 
21 | 		bool_<true>{} = call_<or_<lift_<is_even>>, int_<1>, int_<1>, int_<1>, int_<1>, int_<1>,
22 | 		                      int_<1>, int_<1>, int_<1>, int_<2>>{};
23 | 
24 | 		bool_<true>{} = call_<or_<lift_<is_even>>, int_<2>, int_<2>, int_<2>>{};
25 | 
26 | 		return 0;
27 | 	}
28 | } // namespace logic_test


--------------------------------------------------------------------------------
/include/boost/tmp/detail/dispatch.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef BOOST_TMP_DISPATCH_HPP_INCLUDED
 2 | #define BOOST_TMP_DISPATCH_HPP_INCLUDED
 3 | 
 4 | //  Copyright 2018 Odin Holmes.
 5 | //
 6 | //  Distributed under the Boost Software License, Version 1.0.
 7 | //
 8 | //  See accompanying file LICENSE_1_0.txt or copy at
 9 | //  http://www.boost.org/LICENSE_1_0.txt
10 | 
11 | namespace boost {
12 | 	namespace tmp {
13 | 		namespace detail {
14 | 			constexpr unsigned find_dispatch(unsigned n) {
15 | 				return n <= 8 ? n :
16 | 				                n < 16 ?
17 | 				                9 :
18 | 				                n == 16 ?
19 | 				                16 :
20 | 				                n < 32 ?
21 | 				                17 :
22 | 				                n == 32 ?
23 | 				                32 :
24 | 				                n < 64 ? 33 : n == 64 ? 64 : n < 128 ? 65 : n == 128 ? 128 : 129;
25 | 			}
26 | 
27 | 			template <unsigned N, typename T>
28 | 			struct dispatch;
29 | 
30 | 			template <typename C>
31 | 			struct dispatch_unknown {
32 | 				template <typename... Ts>
33 | 				using f = typename dispatch<find_dispatch(sizeof...(Ts)), C>::template f<Ts...>;
34 | 			};
35 | 		} // namespace detail
36 | 	} // namespace tmp
37 | } // namespace boost
38 | #endif
39 | 


--------------------------------------------------------------------------------
/include/boost/tmp/sequence/erase.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef BOOST_TMP_ERASE_HPP_INCLUDED
 2 | #define BOOST_TMP_ERASE_HPP_INCLUDED
 3 | 
 4 | //  Copyright 2018 Odin Holmes.
 5 | //
 6 | //  Distributed under the Boost Software License, Version 1.0.
 7 | //
 8 | //  See accompanying file LICENSE_1_0.txt or copy at
 9 | //  http://www.boost.org/LICENSE_1_0.txt
10 | 
11 | #include "drop.hpp"
12 | #include "pop_front.hpp"
13 | #include "rotate.hpp"
14 | #include "../vocabulary.hpp"
15 | 
16 | namespace boost {
17 | 	namespace tmp {
18 | 		template <typename N = uint_<0>, typename C = listify_>
19 | 		struct erase_ {};
20 | 
21 | 		namespace detail {
22 | 			template <unsigned N, typename I, typename C>
23 | 			struct dispatch<N, erase_<I, C>> {
24 | 				template <typename... Ts>
25 | 				using f = typename dispatch<
26 | 				        N,
27 | 				        rotate_<I, pop_front_<rotate_<uint_<(sizeof...(Ts) - I::value - 1)>, C>>>>::
28 | 				        template f<Ts...>;
29 | 			};
30 | 			template <typename I, typename C>
31 | 			struct dispatch<0, erase_<I, C>> {
32 | 				template <typename... Ts>
33 | 				using f = typename dispatch<1, C>::template f<nothing_>;
34 | 			};
35 | 		} // namespace detail
36 | 	} // namespace tmp
37 | } // namespace boost
38 | 
39 | #endif


--------------------------------------------------------------------------------
/include/boost/tmp/algorithm/transform.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef BOOST_TMP_TRANSFORM_HPP_INCLUDED
 2 | #define BOOST_TMP_TRANSFORM_HPP_INCLUDED
 3 | 
 4 | //  Copyright 2018 Odin Holmes.
 5 | //
 6 | //  Distributed under the Boost Software License, Version 1.0.
 7 | //
 8 | //  See accompanying file LICENSE_1_0.txt or copy at
 9 | //  http://www.boost.org/LICENSE_1_0.txt
10 | 
11 | #include "../call.hpp"
12 | #include "../vocabulary.hpp"
13 | 
14 | namespace boost {
15 | 	namespace tmp {
16 | 		template <typename F = identity_, typename C = listify_>
17 | 		struct transform_ {};
18 | 		namespace detail {
19 | 			template <unsigned N, typename F, typename C>
20 | 			struct dispatch<N, transform_<F, C>> {
21 | 				template <typename... Ts>
22 | 				using f = typename dispatch<find_dispatch(sizeof...(Ts)), C>::template f<
23 | 				        typename dispatch<1, F>::template f<Ts>...>;
24 | 			};
25 | 
26 | 			template <unsigned N, template <typename...> class F, typename FC, typename C>
27 | 			struct dispatch<N, transform_<lift_<F, FC>, C>> {
28 | 				template <typename... Ts>
29 | 				using f = typename dispatch<(N + (N > sizeof...(Ts))), C>::template f<F<Ts>...>;
30 | 			};
31 | 		} // namespace detail
32 | 	} // namespace tmp
33 | } // namespace boost
34 | 
35 | #endif
36 | 


--------------------------------------------------------------------------------
/include/boost/tmp/try.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef BOOST_TMP_TRY_HPP_INCLUDED
 2 | #define BOOST_TMP_TRY_HPP_INCLUDED
 3 | 
 4 | //  Copyright 2018 Odin Holmes.
 5 | //
 6 | //  Distributed under the Boost Software License, Version 1.0.
 7 | //
 8 | //  See accompanying file LICENSE_1_0.txt or copy at
 9 | //  http://www.boost.org/LICENSE_1_0.txt
10 | 
11 | #include "always.hpp"
12 | #include "detail/dispatch.hpp"
13 | #include "identity.hpp"
14 | #include "sequence/unpack.hpp"
15 | #include "vocabulary.hpp"
16 | 
17 | namespace boost {
18 | 	namespace tmp {
19 | 
20 | 		template <template <typename...> class F, typename C = identity_>
21 | 		struct try_ {};
22 | 
23 | 		namespace detail {
24 | 			template <typename T>
25 | 			struct t_ {
26 | 				using type = T;
27 | 			};
28 | 			template <template <typename...> class F, typename... Ts>
29 | 			t_<F<Ts...>> try_f(lift_<F>, list_<Ts...>);
30 | 			t_<nothing_> try_f(...);
31 | 
32 | 			template <unsigned N, template <typename...> class F, typename C>
33 | 			struct dispatch<N, try_<F, C>> {
34 | 				template <typename... Ts>
35 | 				using f = typename dispatch<1, C>::template f<typename decltype(
36 | 				        try_f(lift_<F>{}, list_<Ts...>{}))::type>;
37 | 			};
38 | 		} // namespace detail
39 | 	} // namespace tmp
40 | } // namespace boost
41 | #endif
42 | 


--------------------------------------------------------------------------------
/include/boost/tmp/sequence/insert.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef BOOST_TMP_INSERT_HPP_INCLUDED
 2 | #define BOOST_TMP_INSERT_HPP_INCLUDED
 3 | 
 4 | //  Copyright 2018 Odin Holmes.
 5 | //
 6 | //  Distributed under the Boost Software License, Version 1.0.
 7 | //
 8 | //  See accompanying file LICENSE_1_0.txt or copy at
 9 | //  http://www.boost.org/LICENSE_1_0.txt
10 | 
11 | #include "drop.hpp"
12 | #include "push_front.hpp"
13 | #include "rotate.hpp"
14 | #include "../vocabulary.hpp"
15 | 
16 | namespace boost {
17 | 	namespace tmp {
18 | 		template <typename N = uint_<0>, typename V = nothing_, typename C = listify_>
19 | 		struct insert_ {};
20 | 
21 | 		namespace detail {
22 | 			template <unsigned N, typename I, typename V, typename C>
23 | 			struct dispatch<N, insert_<I, V, C>> {
24 | 				template <typename... Ts>
25 | 				using f = typename dispatch<
26 | 				        N, rotate_<I, push_front_<V, rotate_<uint_<(sizeof...(Ts) - I::value - 1)>,
27 | 				                                             C>>>>::template f<Ts...>;
28 | 			};
29 | 			template <typename I, typename V, typename C>
30 | 			struct dispatch<0, insert_<I, V, C>> {
31 | 				template <typename... Ts>
32 | 				using f = typename dispatch<1, C>::template f<V>;
33 | 			};
34 | 		} // namespace detail
35 | 	} // namespace tmp
36 | } // namespace boost
37 | 
38 | #endif


--------------------------------------------------------------------------------
/include/boost/tmp/sequence/container.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef BOOST_TMP_CONTAINER_HPP_INCLUDED
 2 | #define BOOST_TMP_CONTAINER_HPP_INCLUDED
 3 | 
 4 | //  Copyright 2018 Odin Holmes.
 5 | //
 6 | //  Distributed under the Boost Software License, Version 1.0.
 7 | //
 8 | //  See accompanying file LICENSE_1_0.txt or copy at
 9 | //  http://www.boost.org/LICENSE_1_0.txt
10 | 
11 | #include "../vocabulary.hpp"
12 | 
13 | namespace boost {
14 | 	namespace tmp {
15 | 		/// \brief
16 | 		template <typename C = identity_>
17 | 		struct container_ {};
18 | 		template <template <typename...> class W, typename C = identity_>
19 | 		using container_is_ = container_<is_<lift_<W>, C>>;
20 | 		namespace detail {
21 | 			template <typename L, typename C>
22 | 			struct container_impl {
23 | 				using type = typename dispatch<1, C>::template f<nothing_>;
24 | 			};
25 | 			template <template <typename...> class Seq, typename C, typename... Ls>
26 | 			struct container_impl<Seq<Ls...>, C> {
27 | 				using type = typename dispatch<1, C>::template f<lift_<Seq>>;
28 | 			};
29 | 
30 | 			template <typename C>
31 | 			struct dispatch<1, container_<C>> {
32 | 				template <typename L>
33 | 				using f = typename detail::container_impl<L, C>::type;
34 | 			};
35 | 		} // namespace detail
36 | 	} // namespace tmp
37 | } // namespace boost
38 | 
39 | #endif
40 | 


--------------------------------------------------------------------------------
/include/boost/tmp/sequence/unpack.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef BOOST_TMP_UNPACK_HPP_INCLUDED
 2 | #define BOOST_TMP_UNPACK_HPP_INCLUDED
 3 | 
 4 | //  Copyright 2018 Odin Holmes.
 5 | //
 6 | //  Distributed under the Boost Software License, Version 1.0.
 7 | //
 8 | //  See accompanying file LICENSE_1_0.txt or copy at
 9 | //  http://www.boost.org/LICENSE_1_0.txt
10 | 
11 | namespace boost {
12 | 	namespace tmp {
13 | 		/// \brief turns a list of types into a variadic pack of those types /
14 | 		/// example: call<all<>,ture_,false_,true_> is equivalent to
15 | 		/// call<unpack<all<>>,list<true_,false_,true_>>
16 | 		template <typename C>
17 | 		struct unpack_ {};
18 | 		namespace detail {
19 | 			template <typename C, typename L>
20 | 			struct unpack_impl;
21 | 			template <typename C, template <typename...> class Seq, typename... Ls>
22 | 			struct unpack_impl<C, Seq<Ls...>> {
23 | 				using type = typename dispatch<find_dispatch(sizeof...(Ls)), C>::template f<Ls...>;
24 | 			};
25 | 
26 | 			template <typename C>
27 | 			struct unpack_impl<C, nothing_> { // in case of nothing_ input give a nothing_ output
28 | 				using type = nothing_;
29 | 			};
30 | 
31 | 			template <typename C>
32 | 			struct dispatch<1, unpack_<C>> {
33 | 				template <typename L>
34 | 				using f = typename detail::unpack_impl<C, L>::type;
35 | 			};
36 | 		} // namespace detail
37 | 	} // namespace tmp
38 | } // namespace boost
39 | 
40 | #endif
41 | 


--------------------------------------------------------------------------------
/include/boost/tmp/algorithm/product.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef BOOST_TMP_PRODUCT_HPP_INCLUDED
 2 | #define BOOST_TMP_PRODUCT_HPP_INCLUDED
 3 | 
 4 | //  Copyright 2018 Odin Holmes.
 5 | //
 6 | //  Distributed under the Boost Software License, Version 1.0.
 7 | //
 8 | //  See accompanying file LICENSE_1_0.txt or copy at
 9 | //  http://www.boost.org/LICENSE_1_0.txt
10 | 
11 | #include "../call.hpp"
12 | #include "../vocabulary.hpp"
13 | 
14 | namespace boost {
15 | 	namespace tmp {
16 | 		template <typename F = listify_, typename C = listify_>
17 | 		struct product_ {};
18 | 
19 | 		namespace detail {
20 | 			template <template <typename...> class F, typename T, typename... Ts>
21 | 			using product_helper_ = list_<F<T, Ts>...>;
22 | 
23 | 			template <template <typename...> class F, typename C, typename T, typename U>
24 | 			struct product_unpacker {};
25 | 
26 | 			template <template <typename...> class F, typename C, typename... Ts, typename... Us>
27 | 			struct product_unpacker<F, C, list_<Ts...>, list_<Us...>> {
28 | 				using type =
29 | 				        typename dispatch<find_dispatch(sizeof...(Ts)),
30 | 				                          join_<C>>::template f<product_helper_<F, Ts, Us...>...>;
31 | 			};
32 | 
33 | 			template <template <typename...> class F, typename C>
34 | 			struct dispatch<2, product_<lift_<F>, C>> {
35 | 				template <typename T, typename U>
36 | 				using f = typename product_unpacker<F, C, T, U>::type;
37 | 			};
38 | 
39 | 			template <typename F, typename C>
40 | 			struct dispatch<2, product_<F, C>>
41 | 			    : dispatch<2, product_<lift_<dispatch<2, F>::template f>, C>> {};
42 | 		} // namespace detail
43 | 	} // namespace tmp
44 | } // namespace boost
45 | 
46 | #endif


--------------------------------------------------------------------------------
/include/boost/tmp/sequence/zip_with_index.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef BOOST_TMP_ZIP_WITH_INDEX_HPP_INCLUDED
 2 | #define BOOST_TMP_ZIP_WITH_INDEX_HPP_INCLUDED
 3 | 
 4 | //  Copyright 2018 Odin Holmes.
 5 | //
 6 | //  Distributed under the Boost Software License, Version 1.0.
 7 | //
 8 | //  See accompanying file LICENSE_1_0.txt or copy at
 9 | //  http://www.boost.org/LICENSE_1_0.txt
10 | 
11 | #include <utility>
12 | #include "../call.hpp"
13 | #include "../sequence/make_sequence.hpp"
14 | #include "../vocabulary.hpp"
15 | 
16 | namespace boost {
17 | 	namespace tmp {
18 | 		template <typename F = listify_, typename C = listify_>
19 | 		struct zip_with_index_ {};
20 | 		namespace detail {
21 | 			template <typename L>
22 | 			struct indexer;
23 | 
24 | 			template <typename... Is>
25 | 			struct indexer<list_<Is...>> {
26 | 				template <typename F, template <typename...> class C, typename... Ts>
27 | 				using f = C<typename dispatch<2, F>::template f<Is, Ts>...>;
28 | 			};
29 | 
30 | 			template <unsigned N>
31 | 			using make_index_for_zip = typename make_seq_impl<next_state(0, N)>::template f<N>;
32 | 
33 | 			template <unsigned N, typename F, typename C>
34 | 			struct dispatch<N, zip_with_index_<F, C>> {
35 | 				template <typename... Ts>
36 | 				using f = typename indexer<make_index_for_zip<sizeof...(Ts)>>::template f<
37 | 				        F, dispatch<find_dispatch(sizeof...(Ts)), C>::template f, Ts...>;
38 | 			};
39 | 			template <unsigned N, typename F, template <typename...> class C>
40 | 			struct dispatch<N, zip_with_index_<F, lift_<C>>> {
41 | 				template <typename... Ts>
42 | 				using f = typename indexer<make_index_for_zip<sizeof...(Ts)>>::template f<F, C,
43 | 				                                                                          Ts...>;
44 | 			};
45 | 		} // namespace detail
46 | 	} // namespace tmp
47 | } // namespace boost
48 | 
49 | #endif
50 | 


--------------------------------------------------------------------------------
/test/find_if_test.hpp:
--------------------------------------------------------------------------------
 1 | #include <memory>
 2 | #include "test_util.hpp"
 3 | #include "../include/boost/tmp/comparison.hpp"
 4 | #include "../include/boost/tmp/fusion/find_if.hpp"
 5 | #include "../include/boost/tmp/pack.hpp"
 6 | #include "../include/boost/tmp/sequence/unpack.hpp"
 7 | 
 8 | namespace find_if_test {
 9 | 	template <typename T>
10 | 	using is_even = bool_<(T::value % 2 == 0)>;
11 | 
12 | 	namespace tmp = boost::tmp;
13 | 
14 | 	constexpr auto a = tmp::val_pack_(
15 | 
16 | 	);
17 | 
18 | 	template <int X>
19 | 	struct equals_to {
20 | 		template <typename Y>
21 | 		using f = tmp::bool_<(Y::value == X)>;
22 | 	};
23 | 
24 | 	int run() {
25 | 
26 | 		uint_<8>{} = call_<find_if_<lift_<is_even>>, int_<1>, int_<1>, int_<1>, int_<1>, int_<1>,
27 | 		                   int_<1>, int_<1>, int_<1>, int_<2>>{};
28 | 		nothing_{} = call_<find_if_<lift_<is_even>>, int_<1>>{};
29 | 
30 | 		uint_<400>{} = call_<make_sequence_<identity_, find_if_<is_<uint_<400>>>>, uint_<500>>{};
31 | #ifdef BOOST_TMP_CPP14
32 | 
33 | 		constexpr auto xs0 = tmp::val_pack_(
34 | 
35 | 		);
36 | 		constexpr auto result0 = xs0 >>= tmp::find_if_<tmp::lift_<equals_to<0>::template f>>{};
37 | 		(void)result0;
38 | 
39 | 		constexpr auto xs1 = tmp::val_pack_(
40 | 		        tmp::int_<1>{}, tmp::int_<2>{}, tmp::int_<3>{}, tmp::int_<4>{}, tmp::int_<5>{},
41 | 		        tmp::int_<6>{}, tmp::int_<7>{}, tmp::int_<8>{}, tmp::int_<9>{}, tmp::int_<10>{});
42 | 		(void)xs1;
43 | 
44 | 		constexpr auto result1 = xs1 >>= tmp::find_if_<tmp::lift_<equals_to<10>::template f>>{};
45 | 		(void)result1;
46 | 
47 | 		(void)(1 == (val_pack_(false, 'a', 1, true) >>= find_if_<is_<int>>{}));
48 | 
49 | 		std::unique_ptr<int> p = pack_(std::unique_ptr<int>{}) >>= find_if_<always_<true_>>{};
50 | #endif
51 | 		return 0;
52 | 	}
53 | } // namespace find_if_test


--------------------------------------------------------------------------------
/test/fold_left_test.hpp:
--------------------------------------------------------------------------------
 1 | #include "test_util.hpp"
 2 | #include "../include/boost/tmp/algorithm/fold_left.hpp"
 3 | #include "../include/boost/tmp/sequence/join.hpp"
 4 | 
 5 | namespace fold_left_test {
 6 | 	template <typename T, typename U>
 7 | 	using add = uint_<(T::value + U::value)>;
 8 | 	template <typename T, typename U>
 9 | 	using push = call_<join_<>, T, list_<U>>;
10 | 	int run() {
11 | 		list_<>{}                   = call_<fold_left_<lift_<push>>, list_<>>{};
12 | 		list_<uint_<1>, uint_<2>>{} = call_<fold_left_<lift_<push>>, list_<>, uint_<1>, uint_<2>>{};
13 | 		list_<uint_<1>, uint_<2>, uint_<3>>{} =
14 | 		        call_<fold_left_<lift_<push>>, list_<>, uint_<1>, uint_<2>, uint_<3>>{};
15 | 		list_<uint_<1>, uint_<2>, uint_<3>, uint_<4>>{} =
16 | 		        call_<fold_left_<lift_<push>>, list_<>, uint_<1>, uint_<2>, uint_<3>, uint_<4>>{};
17 | 		list_<uint_<1>, uint_<1>, uint_<1>, uint_<1>, uint_<1>, uint_<1>, uint_<1>, uint_<1>,
18 | 		      uint_<1>, uint_<1>, uint_<1>, uint_<2>, uint_<3>, uint_<4>>{} =
19 | 		        call_<fold_left_<lift_<push>>, list_<>, uint_<1>, uint_<1>, uint_<1>, uint_<1>,
20 | 		              uint_<1>, uint_<1>, uint_<1>, uint_<1>, uint_<1>, uint_<1>, uint_<1>,
21 | 		              uint_<2>, uint_<3>, uint_<4>>{};
22 | 		uint_<1>{}  = call_<fold_left_<lift_<add>>, uint_<1>>{};
23 | 		uint_<3>{}  = call_<fold_left_<lift_<add>>, uint_<1>, uint_<2>>{};
24 | 		uint_<6>{}  = call_<fold_left_<lift_<add>>, uint_<1>, uint_<2>, uint_<3>>{};
25 | 		uint_<10>{} = call_<fold_left_<lift_<add>>, uint_<1>, uint_<2>, uint_<3>, uint_<4>>{};
26 | 		uint_<20>{} = call_<fold_left_<lift_<add>>, uint_<1>, uint_<1>, uint_<1>, uint_<1>,
27 | 		                    uint_<1>, uint_<1>, uint_<1>, uint_<1>, uint_<1>, uint_<1>, uint_<1>,
28 | 		                    uint_<2>, uint_<3>, uint_<4>>{};
29 | 
30 | 		return 0;
31 | 	}
32 | } // namespace fold_left_test
33 | 


--------------------------------------------------------------------------------
/test/filter_test.hpp:
--------------------------------------------------------------------------------
 1 | #include "test_util.hpp"
 2 | #include "../include/boost/tmp/comparison.hpp"
 3 | #include "../include/boost/tmp/fusion.hpp"
 4 | #include "../include/boost/tmp/fusion/filter.hpp"
 5 | #include "../include/boost/tmp/pack.hpp"
 6 | #include "../include/boost/tmp/sequence/zip.hpp"
 7 | 
 8 | namespace filter_test {
 9 | 	template <typename T>
10 | 	using divide_by_two_celing = int_<((T::value >> 1) + (T::value & 1))>;
11 | 	template <typename T>
12 | 	using multiply_by_2 = uint_<(T::value << 1)>;
13 | 
14 | 	namespace tmp = boost::tmp;
15 | 	template <typename N>
16 | 	using is_even = tmp::bool_<N::value % 2 == 0>;
17 | 	using xs0     = tmp::list_<tmp::int_<1>, tmp::int_<2>, tmp::int_<3>, tmp::int_<4>, tmp::int_<5>,
18 |                            tmp::int_<6>, tmp::int_<7>, tmp::int_<8>, tmp::int_<9>, tmp::int_<10>>;
19 | 	using result0 = tmp::call_<tmp::unpack_<tmp::filter_<tmp::lift_<is_even>>>, xs0>;
20 | 
21 | 	int run() {
22 | 		using make_filtered_sequence = make_sequence_<identity_, filter_<lift_<is_even>>>;
23 | 		using make_stride2_sequence =
24 | 		        lift_<divide_by_two_celing, make_sequence_<lift_<multiply_by_2>>>;
25 | 
26 | 		call_<make_sequence_<make_algo<make_stride2_sequence>>, extent>{} =
27 | 		        call_<make_sequence_<make_algo<make_filtered_sequence>>, extent>{};
28 | 
29 | 		// fusion
30 | #ifdef BOOST_TMP_CPP14
31 | 		int i                 = 1;
32 | 		std::pair<int, int>{} = pack_(false, 'a', i, 2, true) >>=
33 | 		        filter_<lift_<std::remove_reference_t, is_<int>>>{} |
34 | 		        [](auto l, auto r) { return std::make_pair(l, r); };
35 | 		(void)(1 ==
36 | 		       (pack_(false, 'a', 1, true) >>=
37 | 		        filter_<lift_<std::remove_reference_t, is_<int>>>{} | [](auto l) { return l; }));
38 | 		pack_() = pack_() >>= filter_<lift_<is_even>>{};
39 | #endif
40 | 
41 | 		return 0;
42 | 	}
43 | } // namespace filter_test


--------------------------------------------------------------------------------
/include/boost/tmp.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef BOOST_TMP_HPP_INCLUDED
 2 | #define BOOST_TMP_HPP_INCLUDED
 3 | 
 4 | //  Copyright 2018 Odin Holmes.
 5 | //
 6 | //  Distributed under the Boost Software License, Version 1.0.
 7 | //
 8 | //  See accompanying file LICENSE_1_0.txt or copy at
 9 | //  http://www.boost.org/LICENSE_1_0.txt
10 | 
11 | #include "tmp/algorithm/contains.hpp"
12 | #include "tmp/algorithm/count_if.hpp"
13 | #include "tmp/algorithm/filter.hpp"
14 | #include "tmp/algorithm/find_if.hpp"
15 | #include "tmp/algorithm/fold_left.hpp"
16 | #include "tmp/algorithm/fold_right.hpp"
17 | #include "tmp/algorithm/partition.hpp"
18 | #include "tmp/algorithm/product.hpp"
19 | #include "tmp/algorithm/remove_if.hpp"
20 | #include "tmp/algorithm/replace_if.hpp"
21 | #include "tmp/algorithm/sort.hpp"
22 | #include "tmp/algorithm/transform.hpp"
23 | #include "tmp/always.hpp"
24 | #include "tmp/call.hpp"
25 | #include "tmp/comparison.hpp"
26 | #include "tmp/detail/expression.hpp"
27 | #include "tmp/detail/fusion_rebind.hpp"
28 | #include "tmp/fusion/contains.hpp"
29 | #include "tmp/fusion/filter.hpp"
30 | #include "tmp/fusion/find_if.hpp"
31 | #include "tmp/identity.hpp"
32 | #include "tmp/if.hpp"
33 | #include "tmp/lift.hpp"
34 | #include "tmp/logic.hpp"
35 | #include "tmp/pack.hpp"
36 | #include "tmp/sequence/container.hpp"
37 | #include "tmp/sequence/drop.hpp"
38 | #include "tmp/sequence/each.hpp"
39 | #include "tmp/sequence/erase.hpp"
40 | #include "tmp/sequence/insert.hpp"
41 | #include "tmp/sequence/join.hpp"
42 | #include "tmp/sequence/make_sequence.hpp"
43 | #include "tmp/sequence/pop_front.hpp"
44 | #include "tmp/sequence/push_back.hpp"
45 | #include "tmp/sequence/push_front.hpp"
46 | #include "tmp/sequence/reverse.hpp"
47 | #include "tmp/sequence/rotate.hpp"
48 | #include "tmp/sequence/size.hpp"
49 | #include "tmp/sequence/swap.hpp"
50 | #include "tmp/sequence/take.hpp"
51 | #include "tmp/sequence/tee.hpp"
52 | #include "tmp/sequence/unpack.hpp"
53 | #include "tmp/sequence/zip.hpp"
54 | #include "tmp/sequence/zip_with_index.hpp"
55 | #include "tmp/try.hpp"
56 | #include "tmp/vocabulary.hpp"
57 | 
58 | #endif
59 | 


--------------------------------------------------------------------------------
/include/boost/tmp/lift.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef BOOST_TMP_LIFT_HPP_INCLUDED
 2 | #define BOOST_TMP_LIFT_HPP_INCLUDED
 3 | 
 4 | //  Copyright 2018 Odin Holmes.
 5 | //
 6 | //  Distributed under the Boost Software License, Version 1.0.
 7 | //
 8 | //  See accompanying file LICENSE_1_0.txt or copy at
 9 | //  http://www.boost.org/LICENSE_1_0.txt
10 | 
11 | #include "detail/capabilities.hpp"
12 | #include "detail/dispatch.hpp"
13 | #include "identity.hpp"
14 | 
15 | namespace boost {
16 | 	namespace tmp {
17 | 
18 | 		template <template <typename...> class F, typename C = identity_>
19 | 		struct lift_ {};
20 | 
21 | 		template <typename C = identity_>
22 | 		struct result_ {};
23 | 
24 | 		namespace detail {
25 | #ifndef BOOST_TMP_CLANG_ARITY_BUGh
26 | 			template <template <typename...> class F, typename C>
27 | 			struct dispatch<1, lift_<F, C>> {
28 | 				template <typename T>
29 | 				using f = typename dispatch<1, C>::template f<F<T>>;
30 | 			};
31 | 			template <template <typename...> class F, typename C>
32 | 			struct dispatch<2, lift_<F, C>> {
33 | 				template <typename T0, typename T1>
34 | 				using f = typename dispatch<1, C>::template f<F<T0, T1>>;
35 | 			};
36 | 			template <template <typename...> class F, typename C>
37 | 			struct dispatch<3, lift_<F, C>> {
38 | 				template <typename T0, typename T1, typename T2>
39 | 				using f = typename dispatch<1, C>::template f<F<T0, T1, T2>>;
40 | 			};
41 | 			template <template <typename...> class F, typename C>
42 | 			struct dispatch<4, lift_<F, C>> {
43 | 				template <typename T0, typename T1, typename T2, typename T3>
44 | 				using f = typename dispatch<1, C>::template f<F<T0, T1, T2, T3>>;
45 | 			};
46 | #endif
47 | 			template <unsigned N, template <typename...> class F, typename C>
48 | 			struct dispatch<N, lift_<F, C>> {
49 | 				template <typename... Ts>
50 | 				using f = typename dispatch<1, C>::template f<F<Ts...>>;
51 | 			};
52 | 			template <typename C>
53 | 			struct dispatch<1, result_<C>> {
54 | 				template <typename T>
55 | 				using f = typename dispatch<1, C>::template f<typename T::type>;
56 | 			};
57 | 		} // namespace detail
58 | 	} // namespace tmp
59 | } // namespace boost
60 | #endif
61 | 


--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
 1 | sudo: false
 2 | language: cpp
 3 | 
 4 | # More complete test matrix
 5 | matrix:
 6 |   include:
 7 | 
 8 |     - os: linux
 9 |       compiler: gcc
10 |       addons:
11 |         apt:
12 |           sources: ['ubuntu-toolchain-r-test', 'george-edison55-precise-backports']
13 |           packages: ['g++-5', 'cmake', 'cmake-data']
14 |       env: TOOLSET=g++-5
15 | 
16 |     - os: linux
17 |       compiler: gcc
18 |       addons:
19 |         apt:
20 |           sources: ['ubuntu-toolchain-r-test', 'george-edison55-precise-backports']
21 |           packages: ['g++-6', 'cmake', 'cmake-data']
22 |       env: TOOLSET=g++-6
23 | 
24 |     - os: linux
25 |       compiler: clang
26 |       addons:
27 |         apt:
28 |           sources: ['ubuntu-toolchain-r-test', 'llvm-toolchain-precise-3.6', 'george-edison55-precise-backports']
29 |           packages: ['clang-3.6', 'cmake', 'cmake-data']
30 |       env: TOOLSET=clang++-3.6
31 | 
32 |     - os: linux
33 |       compiler: clang
34 |       addons:
35 |         apt:
36 |           sources: ['ubuntu-toolchain-r-test', 'llvm-toolchain-precise-3.7', 'george-edison55-precise-backports']
37 |           packages: ['clang-3.7', 'cmake', 'cmake-data']
38 |       env: TOOLSET=clang++-3.7
39 | 
40 |     - os: linux
41 |       compiler: clang
42 |       addons:
43 |         apt:
44 |           sources: ['ubuntu-toolchain-r-test', 'llvm-toolchain-precise-3.8', 'george-edison55-precise-backports']
45 |           packages: ['clang-3.8', 'cmake', 'cmake-data']
46 |       env: TOOLSET=clang++-3.8
47 | 
48 |     - os: linux
49 |       compiler: clang
50 |       addons:
51 |         apt:
52 |           sources: ['ubuntu-toolchain-r-test', 'llvm-toolchain-precise-3.9', 'george-edison55-precise-backports']
53 |           packages: ['clang-3.9', 'cmake', 'cmake-data']
54 |       env: TOOLSET=clang++-3.9
55 | 
56 |     - os: osx
57 |       compiler: clang
58 |       env: TOOLSET=clang++
59 | 
60 | # before_install:
61 | #
62 | 
63 | # Prepare build
64 | before_script:
65 |   - mkdir build
66 |   - cd build
67 |   - cmake .. -DCMAKE_CXX_COMPILER=$TOOLSET -DMAKE_INCLUDE_TESTS=ON
68 | 
69 | script:
70 |   - make VERBOSE=1
71 | - ./boost_tmp_test
72 | 


--------------------------------------------------------------------------------
/include/boost/tmp/fusion/contains.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef BOOST_TMP_FUSION_CONTAINS_HPP_INCLUDED
 2 | #define BOOST_TMP_FUSION_CONTAINS_HPP_INCLUDED
 3 | 
 4 | //  Copyright 2018 Odin Holmes.
 5 | //
 6 | //  Distributed under the Boost Software License, Version 1.0.
 7 | //
 8 | //  See accompanying file LICENSE_1_0.txt or copy at
 9 | //  http://www.boost.org/LICENSE_1_0.txt
10 | 
11 | #include "../algorithm/contains.hpp"
12 | #include "../identity.hpp"
13 | #include "../logic.hpp"
14 | #include "../sequence/index.hpp"
15 | 
16 | namespace boost {
17 | 	namespace tmp {
18 | 		template <typename V, typename C>
19 | 		struct contains_ {
20 | #ifdef BOOST_TMP_CPP14
21 | 			template <typename CT>
22 | 			auto operator|(CT c) {
23 | 				static_assert(call_<is_<identity_>, C>::value,
24 | 				              "cannot add value continuation, type continuation already specified");
25 | 				return fusion::detail::make_expr<CT>{}(contains_<V, identity_>{}, std::move(c));
26 | 			}
27 | #endif
28 | 		};
29 | 
30 | #ifdef BOOST_TMP_CPP14
31 | 		namespace fusion {
32 | 			template <typename V, typename Tail>
33 | 			struct ast<contains_<V, identity_>, Tail> {
34 | 				contains_<V, identity_> head;
35 | 				Tail tail;
36 | 				template <typename T, typename P>
37 | 				constexpr auto f(T, P) {
38 | 					return tail.f(typename Tail::template exec<T>{},
39 | 					              pack<detail::base<uint_<0>, T>>{{}});
40 | 				};
41 | 				template <typename... Ts>
42 | 				using exec = call_<or_<unpack_<i1_<is_<V>>>>, Ts...>;
43 | 			};
44 | 			template <typename V>
45 | 			struct ast<contains_<V, identity_>, listify_> { // break recursion
46 | 				contains_<V, listify_> head;
47 | 
48 | 				template <typename T, typename P>
49 | 				constexpr auto f(T, P) {
50 | 					return pack<detail::base<uint_<0>, T>>{{}};
51 | 				};
52 | 
53 | 				template <typename... Ts>
54 | 				using exec = call_<or_<unpack_<i1_<is_<V>>>>, Ts...>;
55 | 			};
56 | 
57 | 			template <typename V, typename C>
58 | 			struct rebind<contains_<V, C>> {
59 | 				using type = ast<contains_<V, identity_>, typename rebind<C>::type>;
60 | 			};
61 | 
62 | 			template <typename V>
63 | 			struct rebind<contains_<V, identity_>> {
64 | 				using type = ast<contains_<V, identity_>, listify_>;
65 | 			};
66 | 		} // namespace fusion
67 | #endif
68 | 	} // namespace tmp
69 | } // namespace boost
70 | 
71 | #endif


--------------------------------------------------------------------------------
/include/boost/tmp/sequence/each.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef BOOST_TMP_EACH_HPP_INCLUDED
 2 | #define BOOST_TMP_EACH_HPP_INCLUDED
 3 | 
 4 | //  Copyright 2018 Odin Holmes.
 5 | //
 6 | //  Distributed under the Boost Software License, Version 1.0.
 7 | //
 8 | //  See accompanying file LICENSE_1_0.txt or copy at
 9 | //  http://www.boost.org/LICENSE_1_0.txt
10 | 
11 | #include <utility>
12 | #include "../call.hpp"
13 | #include "../vocabulary.hpp"
14 | 
15 | namespace boost {
16 | 	namespace tmp {
17 | 		template <typename... Fs>
18 | 		struct each_ {};
19 | 		namespace detail {
20 | 			template <typename F, typename C>
21 | 			struct dispatch<1, each_<F, C>> {
22 | 				template <typename T>
23 | 				using f =
24 | 				        typename dispatch<1, C>::template f<typename dispatch<1, F>::template f<T>>;
25 | 			};
26 | 			template <typename F0, typename F1, typename C>
27 | 			struct dispatch<2, each_<F0, F1, C>> {
28 | 				template <typename T0, typename T1>
29 | 				using f =
30 | 				        typename dispatch<2,
31 | 				                          C>::template f<typename dispatch<1, F0>::template f<T0>,
32 | 				                                         typename dispatch<1, F1>::template f<T1>>;
33 | 			};
34 | 			template <typename F0, typename F1, typename F2, typename C>
35 | 			struct dispatch<3, each_<F0, F1, F2, C>> {
36 | 				template <typename T0, typename T1, typename T2>
37 | 				using f =
38 | 				        typename dispatch<2,
39 | 				                          C>::template f<typename dispatch<1, F0>::template f<T0>,
40 | 				                                         typename dispatch<1, F1>::template f<T1>,
41 | 				                                         typename dispatch<1, F2>::template f<T2>>;
42 | 			};
43 | 			template <typename F0, typename F1, typename F2, typename F3, typename C>
44 | 			struct dispatch<4, each_<F0, F1, F2, F3, C>> {
45 | 				template <typename T0, typename T1, typename T2, typename T3>
46 | 				using f =
47 | 				        typename dispatch<2,
48 | 				                          C>::template f<typename dispatch<1, F0>::template f<T0>,
49 | 				                                         typename dispatch<1, F1>::template f<T1>,
50 | 				                                         typename dispatch<1, F2>::template f<T2>,
51 | 				                                         typename dispatch<1, F3>::template f<T3>>;
52 | 			};
53 | 		} // namespace detail
54 | 	} // namespace tmp
55 | } // namespace boost
56 | 
57 | #endif
58 | 


--------------------------------------------------------------------------------
/include/boost/tmp/sequence/make_sequence.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef BOOST_TMP_MAKE_SEQUENCE_HPP_INCLUDED
 2 | #define BOOST_TMP_MAKE_SEQUENCE_HPP_INCLUDED
 3 | 
 4 | //  Copyright 2018 Odin Holmes.
 5 | //
 6 | //  Distributed under the Boost Software License, Version 1.0.
 7 | //
 8 | //  See accompanying file LICENSE_1_0.txt or copy at
 9 | //  http://www.boost.org/LICENSE_1_0.txt
10 | 
11 | #include <utility>
12 | #include "unpack.hpp"
13 | #include "../algorithm/transform.hpp"
14 | #include "../call.hpp"
15 | #include "../vocabulary.hpp"
16 | 
17 | namespace boost {
18 | 	namespace tmp {
19 | 		template <typename F = identity_, typename C = listify_>
20 | 		struct make_sequence_ {};
21 | 		namespace detail {
22 | 			constexpr unsigned next_number(unsigned current, unsigned end) {
23 | 				return ((end - 2 * current) < 2) ?
24 | 				               end :
25 | 				               next_number(current,
26 | 				                           end / 2); // note that unsigned/2 always rounds down
27 | 			}
28 | 
29 | 			constexpr unsigned next_state(unsigned current, unsigned end) {
30 | 				return ((end - current) < 2) ? end - current :
31 | 				                               (2 + (next_number(current, end) - 2 * current));
32 | 			}
33 | 
34 | 			template <unsigned State>
35 | 			struct make_seq_impl;
36 | 			template <>
37 | 			struct make_seq_impl<0> { // done
38 | 				template <unsigned End, unsigned... Is>
39 | 				using f = list_<uint_<Is>...>;
40 | 			};
41 | 			template <>
42 | 			struct make_seq_impl<1> { // done +1
43 | 				template <unsigned End, unsigned... Is>
44 | 				using f = list_<uint_<Is>..., uint_<End - 1>>;
45 | 			};
46 | 			template <>
47 | 			struct make_seq_impl<2> { // double
48 | 				template <unsigned End, unsigned... Is>
49 | 				using f = typename make_seq_impl<next_state(
50 | 				        2 * sizeof...(Is), End)>::template f<End, Is..., (Is + sizeof...(Is))...>;
51 | 			};
52 | 			template <>
53 | 			struct make_seq_impl<3> { // double +1
54 | 				template <unsigned End, unsigned... Is>
55 | 				using f =
56 | 				        typename make_seq_impl<next_state(2 * sizeof...(Is) + 1, End)>::template f<
57 | 				                End, Is..., (Is + sizeof...(Is))..., (2 * sizeof...(Is))>;
58 | 			};
59 | 
60 | 			template <typename F, typename C>
61 | 			struct dispatch<1, make_sequence_<F, C>> {
62 | 				template <typename N>
63 | 				using f = typename dispatch<1, unpack_<transform_<F, C>>>::template f<
64 | 				        typename make_seq_impl<next_state(0, N::value)>::template f<N::value>>;
65 | 			};
66 | 		} // namespace detail
67 | 	} // namespace tmp
68 | } // namespace boost
69 | 
70 | #endif
71 | 


--------------------------------------------------------------------------------
/test/tee_test.hpp:
--------------------------------------------------------------------------------
 1 | #include "test_util.hpp"
 2 | #include "../include/boost/tmp/sequence/tee.hpp"
 3 | 
 4 | namespace tee_test {
 5 | 	using namespace boost::tmp;
 6 | 
 7 | 	int run() {
 8 | 		{
 9 | 			list_<list_<>>{}          = call_<tee_<listify_, listify_>>{};
10 | 			list_<list_<int>>{}       = call_<tee_<listify_, listify_>, int>{};
11 | 			list_<list_<int, bool>>{} = call_<tee_<listify_, listify_>, int, bool>{};
12 | /*			list_<list_<int, bool>, int, bool>{} =
13 | 			        call_<tee_<listify_, forward_as_pack_, listify_>, int, bool>{};
14 | 			list_<list_<int, bool>, list_<int, bool>>{} =
15 | 			        call_<tee_<listify_, listify_, listify_>, int, bool>{};
16 | 			list_<list_<int, bool>, list_<int, bool>, int, bool>{} =
17 | 			        call_<tee_<listify_, listify_, forward_as_pack_, listify_>, int, bool>{};
18 | 			list_<list_<int, bool>, list_<int, bool>, list_<int, bool>>{} =
19 | 			        call_<tee_<listify_, listify_, listify_, listify_>, int, bool>{};
20 | 			list_<list_<int, bool>, list_<int, bool>, list_<int, bool>, int, bool>{} =
21 | 			        call_<tee_<listify_, listify_, listify_, forward_as_pack_, listify_>, int,
22 | 			              bool>{};
23 | 			list_<list_<int, bool>, list_<int, bool>, list_<int, bool>, list_<int, bool>>{} =
24 | 			        call_<tee_<listify_, listify_, listify_, listify_, listify_>, int, bool>{};
25 | 			list_<list_<int, bool>, list_<int, bool>, list_<int, bool>, list_<int, bool>, int,
26 | 			      bool>{} =
27 | 			        call_<tee_<listify_, listify_, listify_, listify_, forward_as_pack_, listify_>,
28 | 			              int, bool>{};*/
29 | 		}
30 | 		{
31 | 			true_{}  = call_<tee_<is_<int>, and_<>>, int>{};
32 | 			false_{} = call_<tee_<is_<int>, is_<int>, and_<>>, char>{};
33 | 			false_{} = call_<tee_<is_<int>, is_<int>, is_<int>, and_<>>, char>{};
34 | 			false_{} = call_<tee_<is_<int>, identity_, and_<>>,
35 | 			                 char>{}; // short circuiting should save from hard error
36 | 			false_{} = call_<tee_<is_<int>, identity_, is_<int>, and_<>>,
37 | 			                 char>{}; // short circuiting should save from hard error
38 | 		}
39 | 		{
40 | 			true_{}  = call_<tee_<is_<int>, or_<>>, int>{};
41 | 			false_{} = call_<tee_<is_<int>, is_<int>, or_<>>, char>{};
42 | 			false_{} = call_<tee_<is_<int>, is_<int>, is_<int>, or_<>>, char>{};
43 | 			true_{}  = call_<tee_<is_<int>, identity_, or_<>>,
44 |                             int>{}; // short circuiting should save from hard error
45 | 			true_{}  = call_<tee_<is_<int>, identity_, is_<int>, or_<>>,
46 |                             int>{}; // short circuiting should save from hard error
47 | 		}
48 | 
49 | 		return 0;
50 | 	}
51 | } // namespace tee_test


--------------------------------------------------------------------------------
/include/boost/tmp/fusion.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef BOOST_TMP_FUSION_HPP_INCLUDED
 2 | #define BOOST_TMP_FUSION_HPP_INCLUDED
 3 | 
 4 | //  Copyright 2018 Odin Holmes.
 5 | //
 6 | //  Distributed under the Boost Software License, Version 1.0.
 7 | //
 8 | //  See accompanying file LICENSE_1_0.txt or copy at
 9 | //  http://www.boost.org/LICENSE_1_0.txt
10 | #include "detail/capabilities.hpp"
11 | #include "detail/expression.hpp"
12 | #include "detail/fusion_execute.hpp"
13 | #include "detail/fusion_rebind.hpp"
14 | #include "pack.hpp"
15 | namespace boost {
16 | 	namespace tmp {
17 | #ifdef BOOST_TMP_CPP14
18 | 		namespace fusion {
19 | 			template <typename... Bs, typename T, typename C>
20 | 			constexpr auto operator>>=(pack<Bs...> &&p, expr<T, C> &&ex) {
21 | 				auto tree  = ex.reverse();
22 | 				using type = typename decltype(tree)::template exec<Bs...>;
23 | 				return tree.f(type{}, std::move(p));
24 | 			};
25 | 			// will SFINAE if there is no rebind specialization
26 | 			template <typename... Bs, typename F, typename RF = typename rebind<F>::type,
27 | 			          typename type = typename RF::template exec<Bs...>>
28 | 			constexpr auto operator>>=(const pack<Bs...> &&p, F f)
29 | 			        -> decltype(RF{}.f(type{}, std::move(p))) {
30 | 				return RF{}.f(type{}, std::move(p));
31 | 			};
32 | 			// will SFINAE if there is no rebind specialization
33 | 			template <typename... Bs, typename F, typename RF = typename rebind<F>::type,
34 | 			          typename type = typename RF::template exec<Bs...>>
35 | 			constexpr auto operator>>=(pack<Bs...> &&p, F f)
36 | 			        -> decltype(RF{}.f(type{}, std::move(p))) {
37 | 				return RF{}.f(type{}, std::move(p));
38 | 			};
39 | 			// will SFINAE if there is no rebind specialization
40 | 			template <typename... Bs, typename F, typename RF = typename rebind<F>::type,
41 | 			          typename type = typename RF::template exec<Bs...>>
42 | 			constexpr auto operator>>=(const pack<Bs...> &p, F f) {
43 | 				return RF{}.f(type{}, p);
44 | 			};
45 | 			// will SFINAE if there is no rebind specialization
46 | 			template <typename... Bs, typename F, typename RF = typename rebind<F>::type>
47 | 			constexpr auto operator>>=(pack<Bs...> &p, F f) {
48 | 				using type = typename RF::template exec<Bs...>;
49 | 				return RF{}.f(type{}, p);
50 | 			};
51 | 			// will SFINAE if rhs can not be called with pack parameters
52 | 			template <typename... Ps, typename F>
53 | 			constexpr auto operator>>=(pack<Ps...> &p, F f)
54 | 			        -> decltype(f(static_cast<Ps &>(p).data...)) {
55 | 				return f(static_cast<Ps &>(p).data...);
56 | 			};
57 | 		} // namespace fusion
58 | #endif
59 | 	} // namespace tmp
60 | } // namespace boost
61 | 
62 | #endif


--------------------------------------------------------------------------------
/include/boost/tmp/detail/expression.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef BOOST_TMP_EXPRESSION_HPP_INCLUDED
 2 | #define BOOST_TMP_EXPRESSION_HPP_INCLUDED
 3 | 
 4 | //  Copyright 2018 Odin Holmes.
 5 | //
 6 | //  Distributed under the Boost Software License, Version 1.0.
 7 | //
 8 | //  See accompanying file LICENSE_1_0.txt or copy at
 9 | //  http://www.boost.org/LICENSE_1_0.txt
10 | 
11 | #include <type_traits>
12 | #include "capabilities.hpp"
13 | #include "../always.hpp"
14 | #include "../pack.hpp"
15 | 
16 | namespace boost {
17 | 	namespace tmp {
18 | #ifdef BOOST_TMP_CPP14
19 | 		namespace fusion {
20 | 
21 | 			template <typename H, typename T>
22 | 			struct ast;
23 | 			// an expression and an ast are both linked lists of expressions however, the AST hast
24 | 			// been reversed (and can be executed)
25 | 			template <typename H, typename T>
26 | 			struct expr {
27 | 				H head;
28 | 				T tail;
29 | 
30 | 				constexpr ast<T, H> reverse() {
31 | 					return {tail, head};
32 | 				}
33 | 				template <typename U>
34 | 				constexpr ast<T, ast<H, U>> reverse(U &&u) {
35 | 					return {std::move(tail), {std::move(head), std::move(u)}};
36 | 				};
37 | 			};
38 | 			template <typename H, typename EH, typename ET>
39 | 			struct expr<H, expr<EH, ET>> {
40 | 				H head;
41 | 				expr<EH, ET> tail;
42 | 				template <typename U>
43 | 				constexpr auto reverse(U &&out) {
44 | 					return tail.reverse(ast<H, U>{std::move(head), std::move(out)});
45 | 				}
46 | 				constexpr auto reverse() {
47 | 					return tail.reverse(ast<H, identity_>{std::move(head), {}});
48 | 				}
49 | 			};
50 | 			template <typename H, typename T>
51 | 			struct ast {
52 | 				H head;
53 | 				T tail;
54 | 			};
55 | 
56 | 			namespace detail {
57 | 				template <typename T>
58 | 				struct exec_callable {
59 | 					template <typename...>
60 | 					using exec = int;
61 | 					T fun;
62 | 					template <typename X, typename... Ts>
63 | 					constexpr auto f(X, pack<Ts...> &&p) {
64 | 						return fun(static_cast<Ts &>(p).data...);
65 | 					};
66 | 				};
67 | 
68 | 				template <typename T, typename = void>
69 | 				struct make_expr {
70 | 					template <typename L, typename R>
71 | 					constexpr expr<exec_callable<T>, L> operator()(L l, R r) {
72 | 						return {{r}, l};
73 | 					}
74 | 				};
75 | 
76 | 				template <typename T>
77 | 				struct voider {
78 | 					using type = void;
79 | 				};
80 | 
81 | 				template <typename T>
82 | 				struct make_expr<T, typename voider<typename rebind<T>::type>::type> {
83 | 					template <typename L, typename R>
84 | 					constexpr expr<typename rebind<T>::type, L> operator()(L l, R r) {
85 | 						return {{}, l};
86 | 					}
87 | 				};
88 | 			} // namespace detail
89 | 		} // namespace fusion
90 | #endif
91 | 	} // namespace tmp
92 | } // namespace boost
93 | #endif
94 | 


--------------------------------------------------------------------------------
/include/boost/tmp/if.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef BOOST_TMP_IF_HPP_INCLUDED
 2 | #define BOOST_TMP_IF_HPP_INCLUDED
 3 | 
 4 | //  Copyright 2018 Odin Holmes.
 5 | //
 6 | //  Distributed under the Boost Software License, Version 1.0.
 7 | //
 8 | //  See accompanying file LICENSE_1_0.txt or copy at
 9 | //  http://www.boost.org/LICENSE_1_0.txt
10 | 
11 | #include "vocabulary.hpp"
12 | 
13 | #if defined(__has_builtin)
14 | #if __has_builtin(__type_pack_element)
15 | #define BOOST_TMP_USE_TYPE_PACK_ELEMENT_INTRINSIC
16 | #endif
17 | #endif
18 | 
19 | namespace boost {
20 | 	namespace tmp {
21 | 		template <typename P, typename T, typename F = always_<nothing_>>
22 | 		struct if_ {};
23 | 
24 | 		namespace detail {
25 | 			template <bool B>
26 | 			struct if_impl;
27 | 
28 | 			template <>
29 | 			struct if_impl<true> {
30 | 				template <typename T, typename U>
31 | 				using f = T;
32 | 			};
33 | 
34 | 			template <>
35 | 			struct if_impl<false> {
36 | 				template <typename T, typename U>
37 | 				using f = U;
38 | 			};
39 | 
40 | 			template <typename P, typename T, typename F>
41 | 			struct dispatch<1, if_<P, T, F>> {
42 | 				template <typename T0>
43 | 				using f =
44 | 				        typename dispatch<1, typename if_impl<dispatch<1, P>::template f<
45 | 				                                     T0>::value>::template f<T, F>>::template f<T0>;
46 | 			};
47 | 
48 | 			template <template <typename...> class P, typename T, typename F>
49 | 			struct dispatch<1, if_<lift_<P>, T, F>> {
50 | 				template <typename T0>
51 | 				using f = typename dispatch<
52 | 				        1, typename if_impl<P<T0>::value>::template f<T, F>>::template f<T0>;
53 | 			};
54 | 
55 | 			template <unsigned N, typename P, typename T, typename F>
56 | 			struct dispatch<N, if_<P, T, F>> {
57 | 				template <typename... Ts>
58 | 				using f = typename dispatch<
59 | 				        find_dispatch(sizeof...(Ts)),
60 | 				        typename if_impl<dispatch<find_dispatch(sizeof...(Ts)), P>::template f<
61 | 				                Ts...>::value>::template f<T, F>>::template f<Ts...>;
62 | 			};
63 | 			template <unsigned N, template <typename...> class P, typename T, typename F>
64 | 			struct dispatch<N, if_<lift_<P>, T, F>> {
65 | 				template <typename... Ts>
66 | 				using f = typename dispatch<
67 | 				        find_dispatch(sizeof...(Ts)),
68 | 				        typename if_impl<P<Ts...>::value>::template f<T, F>>::template f<Ts...>;
69 | 			};
70 | 			template <template <typename...> class P>
71 | 			struct dispatch<1, if_<lift_<P>, listify_, always_<list_<>>>> {
72 | 				template <typename U>
73 | #if defined(BOOST_TMP_USE_TYPE_PACK_ELEMENT_INTRINSIC)
74 | 				using f = __type_pack_element<(P<U>::value != 0), list_<U>, list_<>>;
75 | #else
76 | 				using f = typename if_impl<P<U>::value>::template f<list_<U>, list_<>>;
77 | #endif
78 | 			};
79 | 		} // namespace detail
80 | 	} // namespace tmp
81 | } // namespace boost
82 | #endif
83 | 


--------------------------------------------------------------------------------
/.clang-format:
--------------------------------------------------------------------------------
 1 | ---
 2 | Language:        Cpp
 3 | BasedOnStyle:  LLVM
 4 | AccessModifierOffset: -4
 5 | 
 6 | AlignAfterOpenBracket: Align
 7 | AlignConsecutiveAssignments: true
 8 | AlignConsecutiveDeclarations: false
 9 | AlignEscapedNewlinesLeft: true
10 | AlignOperands:   true
11 | AlignTrailingComments: false
12 | AllowAllParametersOfDeclarationOnNextLine: true
13 | AllowShortBlocksOnASingleLine: false
14 | AllowShortCaseLabelsOnASingleLine: false
15 | AllowShortFunctionsOnASingleLine: None
16 | AllowShortIfStatementsOnASingleLine: false
17 | AllowShortLoopsOnASingleLine: false
18 | AlwaysBreakAfterDefinitionReturnType: None
19 | AlwaysBreakAfterReturnType: None
20 | AlwaysBreakBeforeMultilineStrings: true
21 | AlwaysBreakTemplateDeclarations: true
22 | BinPackArguments: true
23 | BinPackParameters: true
24 | BraceWrapping:
25 |   AfterClass:               false
26 |   AfterControlStatement:    false
27 |   AfterEnum:                false
28 |   AfterFunction:            false
29 |   AfterNamespace:           false
30 |   AfterObjCDeclaration:     false
31 |   AfterStruct:              false
32 |   AfterUnion:               false
33 |   BeforeCatch:              false
34 |   BeforeElse:               false
35 |   IndentBraces:             false
36 | BreakBeforeBinaryOperators: None
37 | BreakBeforeBraces: Attach
38 | BreakBeforeTernaryOperators: false
39 | BreakConstructorInitializersBeforeComma: false
40 | ColumnLimit:     100
41 | CommentPragmas:  '^ IWYU pragma:'
42 | ConstructorInitializerAllOnOneLineOrOnePerLine: true
43 | ConstructorInitializerIndentWidth: 4
44 | ContinuationIndentWidth: 8
45 | Cpp11BracedListStyle: true
46 | DerivePointerAlignment: false
47 | DisableFormat:   false
48 | ExperimentalAutoDetectBinPacking: false
49 | ForEachMacros:   [ foreach, Q_FOREACH, BOOST_FOREACH ]
50 | IncludeCategories:
51 |   - Regex:           '"\.\./.*'
52 |     Priority:        4
53 |   - Regex:           '".*'
54 |     Priority:        3
55 |   - Regex:           '.*\.hpp.'
56 |     Priority:        2
57 |   - Regex:           '.*'
58 |     Priority:        1
59 | IndentCaseLabels: false
60 | IndentWidth:     4
61 | IndentWrappedFunctionNames: false
62 | KeepEmptyLinesAtTheStartOfBlocks: true
63 | MacroBlockBegin: ''
64 | MacroBlockEnd:   ''
65 | MaxEmptyLinesToKeep: 1
66 | NamespaceIndentation: All
67 | ObjCBlockIndentWidth: 2
68 | ObjCSpaceAfterProperty: false
69 | ObjCSpaceBeforeProtocolList: true
70 | PenaltyBreakBeforeFirstCallParameter: 20
71 | PenaltyBreakComment: 1000
72 | PenaltyBreakFirstLessLess: 1000
73 | PenaltyBreakString: 1000
74 | PenaltyExcessCharacter: 1000
75 | PenaltyReturnTypeOnItsOwnLine: 60
76 | PointerAlignment: Right
77 | ReflowComments:  true
78 | SortIncludes:    true
79 | SpaceAfterCStyleCast: false
80 | SpaceBeforeAssignmentOperators: true
81 | SpaceBeforeParens: ControlStatements
82 | SpaceInEmptyParentheses: false
83 | SpacesBeforeTrailingComments: 1
84 | SpacesInAngles:  false
85 | SpacesInContainerLiterals: true
86 | SpacesInCStyleCastParentheses: false
87 | SpacesInParentheses: false
88 | SpacesInSquareBrackets: false
89 | Standard:        Cpp11
90 | TabWidth:        4
91 | UseTab:          ForIndentation
92 | ...
93 | 
94 | 


--------------------------------------------------------------------------------
/include/boost/tmp/call.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef BOOST_TMP_CALL_HPP_INCLUDED
 2 | #define BOOST_TMP_CALL_HPP_INCLUDED
 3 | 
 4 | //  Copyright 2018 Odin Holmes.
 5 | //
 6 | //  Distributed under the Boost Software License, Version 1.0.
 7 | //
 8 | //  See accompanying file LICENSE_1_0.txt or copy at
 9 | //  http://www.boost.org/LICENSE_1_0.txt
10 | 
11 | #include <type_traits>
12 | #include "detail/capabilities.hpp"
13 | #include "detail/dispatch.hpp"
14 | #include "vocabulary.hpp"
15 | 
16 | namespace boost {
17 | 	namespace tmp {
18 | 		namespace detail {
19 | 			template <bool B>
20 | 			struct maybe_test_impl {
21 | 				template <typename T>
22 | 				using f = T;
23 | 			};
24 | 			template <>
25 | 			struct maybe_test_impl<true> {};
26 | 
27 | 			template <typename T>
28 | 			using maybe_impl =
29 | 			        typename maybe_test_impl<std::is_same<T, nothing_>::value>::template f<T>;
30 | 
31 | 			template <typename F, typename... Ts> // workaround for old clang
32 | 			struct call_impl {
33 | 				using type = typename dispatch<find_dispatch(sizeof...(Ts)), F>::template f<Ts...>;
34 | 			};
35 | 		} // namespace detail
36 | 
37 | #if defined(BOOST_TMP_CLANG_ARITY_BUG)
38 | 		template <typename T, typename... Ts>
39 | 		using call_ = typename detail::call_impl<T, Ts...>::type;
40 | #else
41 | 		template <typename F, typename... Ts>
42 | 		using call_ = typename detail::dispatch<detail::find_dispatch(sizeof...(Ts)),
43 | 		                                        F>::template f<Ts...>;
44 | #endif
45 | 		template <typename T, typename... Ts>
46 | 		using call_t = typename detail::dispatch<detail::find_dispatch(sizeof...(Ts)),
47 | 		                                         T>::template f<Ts...>::type;
48 | #if defined(__cpp_variable_templates)
49 | 		template <typename T, typename... Ts>
50 | 		constexpr auto call_v =
51 | 		        detail::dispatch<detail::find_dispatch(sizeof...(Ts)), T>::template f<Ts...>::value;
52 | #endif
53 | 
54 | 		template <typename C = identity_>
55 | 		struct call_f_ {};
56 | 
57 | 		namespace detail {
58 | 			template <unsigned N, typename C>
59 | 			struct dispatch<N, call_f_<C>> {
60 | 				template <typename F, typename... Ts>
61 | 				using f = typename dispatch<1, C>::template f<typename dispatch<
62 | 				        detail::find_dispatch(sizeof...(Ts)), F>::template f<Ts...>>;
63 | 			};
64 | 		} // namespace detail
65 | 
66 | 		template <typename T, typename... Ts>
67 | 		using maybe_ =
68 | 		        detail::maybe_impl<typename detail::dispatch<detail::find_dispatch(sizeof...(Ts)),
69 | 		                                                     T>::template f<Ts...>>;
70 | 
71 | 		template <typename T, typename... Ts>
72 | 		using maybe_t =
73 | 		        detail::maybe_impl<typename detail::dispatch<detail::find_dispatch(sizeof...(Ts)),
74 | 		                                                     T>::template f<Ts...>::type>;
75 | 
76 | #if defined(__cpp_variable_templates)
77 | 		template <typename T, typename... Ts>
78 | 		constexpr auto maybe_v =
79 | 		        detail::maybe_impl<typename detail::dispatch<detail::find_dispatch(sizeof...(Ts)),
80 | 		                                                     T>::template f<Ts...>>::value;
81 | #endif
82 | 	} // namespace tmp
83 | } // namespace boost
84 | #endif
85 | 


--------------------------------------------------------------------------------
/include/boost/tmp/algorithm/filter.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef BOOST_TMP_FILTER_HPP_INCLUDED
 2 | #define BOOST_TMP_FILTER_HPP_INCLUDED
 3 | 
 4 | //  Copyright 2018 Odin Holmes.
 5 | //
 6 | //  Distributed under the Boost Software License, Version 1.0.
 7 | //
 8 | //  See accompanying file LICENSE_1_0.txt or copy at
 9 | //  http://www.boost.org/LICENSE_1_0.txt
10 | 
11 | #include "../detail/capabilities.hpp"
12 | #include "../detail/dispatch.hpp"
13 | #include "../vocabulary.hpp"
14 | 
15 | namespace boost {
16 | 	namespace tmp {
17 | 		template <typename F, typename C = listify_>
18 | 		struct filter_ {};
19 | 
20 | 		namespace detail {
21 | 			template <unsigned N, template <typename...> class F, typename C>
22 | 			struct filtery;
23 | 
24 | 			template <template <typename...> class F, typename C>
25 | 			struct filtery<0, F, C> {
26 | 				template <unsigned N, typename T, typename U, typename... Ts>
27 | 				using f = typename filtery<(F<U>::value + 2 * (N == 1)), F,
28 | 				                           C>::template f<(N - 1), U, Ts...>;
29 | 			};
30 | 			template <template <typename...> class F, typename C>
31 | 			struct filtery<1, F, C> {
32 | 				template <unsigned N, typename T, typename U, typename... Ts>
33 | 				using f = typename filtery<(F<U>::value + 2 * (N == 1)), F,
34 | 				                           C>::template f<(N - 1), U, Ts..., T>;
35 | 			};
36 | 			template <template <typename...> class F, typename C>
37 | 			struct filtery<2, F, C> { // all the way around, remove last
38 | 				template <unsigned N, typename T, typename... Ts>
39 | 				using f = typename dispatch<find_dispatch(sizeof...(Ts)), C>::template f<Ts...>;
40 | 			};
41 | 			template <template <typename...> class F, typename C>
42 | 			struct filtery<3, F, C> { // all the way around, keep last
43 | 				template <unsigned N, typename T, typename... Ts>
44 | 				using f = typename dispatch<find_dispatch(sizeof...(Ts) + 1), C>::template f<Ts...,
45 | 				                                                                             T>;
46 | 			};
47 | 
48 | 			template <unsigned N, template <typename...> class F, typename C>
49 | 			struct dispatch<N, filter_<lift_<F>, C>> {
50 | 				template <typename T, typename... Ts>
51 | 				using f = typename filtery<(F<T>::value + 2 * (sizeof...(Ts) == 0)), F,
52 | 				                           C>::template f<(sizeof...(Ts)), T, Ts...>;
53 | 			};
54 | 
55 | 			template <unsigned N, typename F, typename C>
56 | 			struct dispatch<N, filter_<F, C>> {
57 | 				template <typename T, typename... Ts>
58 | 				using f = typename filtery<
59 | 				        (dispatch<1, F>::template f<T>::value + 2 * (sizeof...(Ts) == 0)),
60 | 				        dispatch<1, F>::template f, C>::template f<(sizeof...(Ts)), T, Ts...>;
61 | 			};
62 | 
63 | 			template <typename F, typename C>
64 | 			struct dispatch<0, filter_<F, C>> {
65 | 				template <typename... Ts>
66 | 				using f = typename dispatch<0, C>::template f<>;
67 | 			};
68 | 			template <template <typename...> class F, typename C>
69 | 			struct dispatch<0, filter_<lift_<F>, C>> {
70 | 				template <typename... Ts>
71 | 				using f = typename dispatch<0, C>::template f<>;
72 | 			};
73 | 		} // namespace detail
74 | 	} // namespace tmp
75 | } // namespace boost
76 | 
77 | #endif


--------------------------------------------------------------------------------
/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | cmake_minimum_required(VERSION 3.0)
 2 | project(boost_tmp)
 3 | 
 4 | # create the moost_tmp library target
 5 | add_library(boost_tmp INTERFACE)
 6 | # tmp requires a number of features to compile, this will automatically set the c++ standard version
 7 | # to support those features. The c++ version is not explicitly set, so that cmake can figure
 8 | # things out by itself
 9 | target_compile_features(boost_tmp INTERFACE
10 | 		#cxx_generic_lambdas
11 | 		cxx_variable_templates
12 | 		cxx_variadic_templates
13 | 		cxx_constexpr
14 | 		cxx_alias_templates
15 | 		cxx_auto_type
16 | 		cxx_long_long_type
17 | 		cxx_right_angle_brackets
18 | 		cxx_static_assert
19 | 		cxx_uniform_initialization
20 | 		#cxx_user_literals
21 | 		${CPP_EXTRA_FEATURES})
22 | 
23 | include_directories(${CMAKE_CURRENT_SOURCE_DIR}/include/boost/)
24 | 
25 | add_executable(boost_tmp_test test/test.cpp)
26 | target_link_libraries(boost_tmp_test boost_tmp)
27 | target_compile_options(boost_tmp_test PUBLIC -ftemplate-depth=2048 -Wall)
28 | 
29 | option(MAKE_INCLUDE_TESTS OFF)
30 | if (MAKE_INCLUDE_TESTS)
31 | 	function(convert_name out filename)
32 | 		string(REGEX REPLACE "[\\./]" "_" result "${filename}")
33 | 		set(${out} ${result} PARENT_SCOPE)
34 | 	endfunction()
35 | 	function(make_test_includes_file file)
36 | 		convert_name(basename "${file}")
37 | 		file(WRITE ${CMAKE_BINARY_DIR}/include_test/${basename}.cpp
38 | 				"#include <${file}>\nint main() {}")
39 | 	endfunction()
40 | 	file(GLOB_RECURSE headers RELATIVE "${CMAKE_CURRENT_LIST_DIR}/tmp/"
41 | 			"${CMAKE_CURRENT_LIST_DIR}/tmp/*.hpp")
42 | 	foreach(file IN LISTS headers)
43 | 		make_test_includes_file(${file})
44 | 		convert_name(basename "${file}")
45 | 		add_executable(${basename} include_test/${basename}.cpp)
46 | 		target_link_libraries(${basename} boost_tmp)
47 | 		target_compile_options(${basename} PUBLIC -Wall)
48 | 		add_dependencies(boost_tmp_test ${basename})
49 | 	endforeach()
50 | 	file(GLOB_RECURSE tests RELATIVE "${CMAKE_CURRENT_LIST_DIR}/"
51 | 			"${CMAKE_CURRENT_LIST_DIR}/test/*.hpp")
52 | 	foreach (file IN LISTS tests)
53 | 		make_test_includes_file(${file})
54 | 		convert_name(basename "${file}")
55 | 		add_executable(${basename} include_test/${basename}.cpp)
56 | 		target_link_libraries(${basename} boost_tmp)
57 | 		target_include_directories(${basename} PRIVATE ${CMAKE_CURRENT_LIST_DIR})
58 | 		target_compile_options(${basename} PUBLIC -Wall)
59 | 		add_dependencies(boost_tmp_test ${basename})
60 | 	endforeach ()
61 | endif ()
62 | 
63 | # Add Standardese target
64 | find_program(STANDARDESE standardese HINTS ${STANDARDESE_ROOT})
65 | 
66 | if (STANDARDESE)
67 | 	set(BOOST_TMP_DOCS_DIR ${CMAKE_BINARY_DIR}/doc/standardese)
68 | 	message(STATUS "Found standardese for documentation generation")
69 | 	message(STATUS "Documentation dir is: ${BOOST_TMP_DOCS_DIR}")
70 | 	file(MAKE_DIRECTORY ${BOOST_TMP_DOCS_DIR})
71 | 	add_custom_target(
72 | 			standardese
73 | 			COMMAND ${STANDARDESE}
74 | 			-I${CMAKE_SOURCE_DIR}/include/boost/tmp
75 | 			--input.blacklist_namespace=detail
76 | 			--compilation.comments_in_macro=false
77 | 			--output.require_comment_for_full_synopsis=false
78 | 			--output.format=html
79 | 			${CMAKE_SOURCE_DIR}/include/boost/tmp
80 | 			WORKING_DIRECTORY ${BOOST_TMP_DOCS_DIR}
81 | 	)
82 | endif (STANDARDESE)
83 | 


--------------------------------------------------------------------------------
/include/boost/tmp/fusion/find_if.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef BOOST_TMP_FUSION_FIND_IF_HPP_INCLUDED
 2 | #define BOOST_TMP_FUSION_FIND_IF_HPP_INCLUDED
 3 | 
 4 | //  Copyright 2018 Odin Holmes.
 5 | //
 6 | //  Distributed under the Boost Software License, Version 1.0.
 7 | //
 8 | //  See accompanying file LICENSE_1_0.txt or copy at
 9 | //  http://www.boost.org/LICENSE_1_0.txt
10 | 
11 | #include "../algorithm/find_if.hpp"
12 | #include "../detail/capabilities.hpp"
13 | #include "../fusion.hpp"
14 | #include "../sequence/index.hpp"
15 | #include "../sequence/size.hpp"
16 | #include "../sequence/unpack.hpp"
17 | namespace boost {
18 | 	namespace tmp {
19 | #ifdef BOOST_TMP_CPP14
20 | 		template <typename F>
21 | 		struct find_if_<F, listify_> {
22 | 			template <typename CT>
23 | 			auto operator|(CT c) {
24 | 				return fusion::detail::make_expr<CT>{}(find_if_<F, listify_>{}, std::move(c));
25 | 			}
26 | 		};
27 | 		namespace fusion {
28 | 			template <typename F, typename Tail>
29 | 			struct ast<find_if_<F, identity_>, Tail> {
30 | 				find_if_<F, identity_> head;
31 | 				Tail tail;
32 | 				template <typename... Is, typename... Ns, typename... Ts>
33 | 				constexpr auto f(list_<list_<Is...>, list_<Ns...>>, Ts... as) {
34 | 					auto p = pack<detail::base<Ns, Ts>...>{std::forward<Ts>(as)...};
35 | 					return tail.f(typename Tail::template exec<typename Is::type...>{},
36 | 					              static_cast<Is &>(p).data...);
37 | 				};
38 | 				template <typename... Ts>
39 | 				using exec =
40 | 				        call_<tee_<zip_with_index_<lift_<detail::base>, find_if_<unpack_<i1_<F>>>>,
41 | 				                   size_<make_sequence_<>>, listify_>,
42 | 				              Ts...>;
43 | 			};
44 | 			template <typename F>
45 | 			struct ast<find_if_<F, identity_>, listify_> { // break recursion
46 | 				find_if_<F, identity_> head;
47 | 				template <typename... Bs> // not found case
48 | 				constexpr nothing_ f(list_<nothing_>, const pack<Bs...> &p) {
49 | 					return nothing_{};
50 | 				};
51 | 				template <typename T, typename... Bs>
52 | 				constexpr auto f(list_<T>, pack<Bs...> &p) -> typename T::type {
53 | 					return static_cast<T &>(p).get();
54 | 				};
55 | 				template <typename T, typename... Bs>
56 | 				constexpr auto f(list_<T>, const pack<Bs...> &p) -> typename T::type {
57 | 					return static_cast<const T &>(p).get();
58 | 				};
59 | 				template <typename T, typename... Bs>
60 | 				constexpr auto f(list_<T>, const pack<Bs...> &&p) -> typename T::type {
61 | 					return static_cast<const T &&>(p).get();
62 | 				};
63 | 				template <typename T, typename... Bs>
64 | 				constexpr auto f(list_<T>, pack<Bs...> &&p) -> typename T::type {
65 | 					return static_cast<T &&>(p).get();
66 | 				};
67 | 				template <typename... Ts>
68 | 				using exec =
69 | 				        list_<call_<tee_<find_if_<unpack_<i1_<F>>, lift_<index_, lift_<unpack_>>>,
70 | 				                         listify_, call_f_<>>,
71 | 				                    Ts...>>;
72 | 			};
73 | 
74 | 			template <typename F, typename C>
75 | 			struct rebind<find_if_<F, C>> {
76 | 				using type = ast<find_if_<F, identity_>, typename rebind<C>::type>;
77 | 			};
78 | 
79 | 			template <typename F>
80 | 			struct rebind<find_if_<F, identity_>> {
81 | 				using type = ast<find_if_<F, identity_>, listify_>;
82 | 			};
83 | 		} // namespace fusion
84 | #endif
85 | 	} // namespace tmp
86 | } // namespace boost
87 | 
88 | #endif


--------------------------------------------------------------------------------
/include/boost/tmp/algorithm/find_if.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef BOOST_TMP_FIND_IF_HPP_INCLUDED
 2 | #define BOOST_TMP_FIND_IF_HPP_INCLUDED
 3 | 
 4 | //  Copyright 2018 Odin Holmes.
 5 | //
 6 | //  Distributed under the Boost Software License, Version 1.0.
 7 | //
 8 | //  See accompanying file LICENSE_1_0.txt or copy at
 9 | //  http://www.boost.org/LICENSE_1_0.txt
10 | 
11 | #include "../detail/capabilities.hpp"
12 | #include "../vocabulary.hpp"
13 | namespace boost {
14 | 	namespace tmp {
15 | 		template <typename F, typename C = identity_>
16 | 		struct find_if_ {};
17 | 		namespace detail {
18 | 			template <typename T>
19 | 			using id_ = T; // weird clang workaround
20 | 			template <bool Found, int At, template <typename...> class F>
21 | 			struct county {
22 | 				static constexpr int value = -1;
23 | 				template <typename T>
24 | 				using f = county<F<T>::value, (At + 1), F>;
25 | 			};
26 | 			template <int At, template <typename...> class F>
27 | 			struct county<true, At, F> {
28 | 				template <typename T>
29 | 				using f                    = county;
30 | 				static constexpr int value = At;
31 | 			};
32 | 
33 | 			constexpr unsigned select_foldey_loop(int rest_size) {
34 | 				return rest_size < 8 ? (rest_size == 0 ? 1000 : 1001) : 1008;
35 | 			}
36 | 			constexpr unsigned select_foldey(int chunk_size, int rest_size, int found_at_index) {
37 | 				return found_at_index == -1 ? select_foldey_loop(rest_size) :
38 | 				                              chunk_size - found_at_index;
39 | 			}
40 | 			template <unsigned S>
41 | 			struct foldey {
42 | 				template <typename F, unsigned N, typename...>
43 | 				using f = uint_<N - S>;
44 | 			};
45 | 			template <>
46 | 			struct foldey<1000> {
47 | 				template <typename F, unsigned N, typename... Ts>
48 | 				using f = nothing_;
49 | 			};
50 | 			template <>
51 | 			struct foldey<1001> {
52 | 				template <typename F, unsigned N, typename T0, typename... Ts>
53 | 				using f = typename foldey<select_foldey(
54 | 				        1, sizeof...(Ts), F::template f<T0>::value)>::template f<F, N + 1, Ts...>;
55 | 			};
56 | 			template <>
57 | 			struct foldey<1008> {
58 | 				template <typename F, unsigned N, typename T0, typename T1, typename T2,
59 | 				          typename T3, typename T4, typename T5, typename T6, typename T7,
60 | 				          typename... Ts>
61 | 				using f = typename foldey<select_foldey(
62 | 				        8, sizeof...(Ts),
63 | 				        id_<typename F::template f<T0>::template f<T1>::template f<T2>::template f<
64 | 				                T3>::template f<T4>::template f<T5>::template f<T6>::
65 | 				                    template f<T7>>::value)>::template f<F, N + 8, Ts...>;
66 | 			};
67 | 
68 | 			template <>
69 | 			struct foldey<1000000> {};
70 | 
71 | 			template <unsigned N, typename F, typename C>
72 | 			struct dispatch<N, find_if_<F, C>> {
73 | 				template <typename... Ts>
74 | 				using f = typename dispatch<1, C>::template f<
75 | 				        typename foldey<select_foldey_loop(sizeof...(Ts))>::template f<
76 | 				                county<false, -1, dispatch<1, F>::template f>, 0, Ts...>>;
77 | 			};
78 | 
79 | 			template <unsigned N, template <typename...> class F, typename C>
80 | 			struct dispatch<N, find_if_<lift_<F>, C>> {
81 | 				template <typename... Ts>
82 | 				using f = typename dispatch<1, C>::template f<typename foldey<select_foldey_loop(
83 | 				        sizeof...(Ts))>::template f<county<false, -1, F>, 0, Ts...>>;
84 | 			};
85 | 		} // namespace detail
86 | 	} // namespace tmp
87 | } // namespace boost
88 | 
89 | #endif


--------------------------------------------------------------------------------
/include/boost/tmp/fusion/filter.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef BOOST_TMP_FUSION_FILTER_HPP_INCLUDED
 2 | #define BOOST_TMP_FUSION_FILTER_HPP_INCLUDED
 3 | 
 4 | //  Copyright 2018 Odin Holmes.
 5 | //
 6 | //  Distributed under the Boost Software License, Version 1.0.
 7 | //
 8 | //  See accompanying file LICENSE_1_0.txt or copy at
 9 | //  http://www.boost.org/LICENSE_1_0.txt
10 | 
11 | #include "../algorithm/filter.hpp"
12 | #include "../call.hpp"
13 | #include "../comparison.hpp"
14 | #include "../detail/capabilities.hpp"
15 | #include "../detail/dispatch.hpp"
16 | #include "../detail/expression.hpp"
17 | #include "../pack.hpp"
18 | #include "../sequence/index.hpp"
19 | #include "../sequence/make_sequence.hpp"
20 | #include "../sequence/tee.hpp"
21 | #include "../sequence/zip_with_index.hpp"
22 | #include "../vocabulary.hpp"
23 | 
24 | namespace boost {
25 | 	namespace tmp {
26 | #ifdef BOOST_TMP_CPP14
27 | 		template <typename F>
28 | 		struct filter_<F, listify_> {
29 | 			template <typename CT>
30 | 			auto operator|(CT c) {
31 | 				return fusion::detail::make_expr<CT>{}(filter_<F, listify_>{}, std::move(c));
32 | 			}
33 | 		};
34 | 		namespace fusion {
35 | 			template <typename F, typename Tail>
36 | 			struct ast<filter_<F, listify_>, Tail> {
37 | 				filter_<F, listify_> head;
38 | 				Tail tail;
39 | 				template <typename... Ts, typename... FBs, typename... Bs>
40 | 				constexpr auto f(list_<list_<FBs...>, list_<Ts...>>, const pack<Bs...> &&p) {
41 | 					return tail.f(
42 | 					        typename Tail::template exec<Ts...>{},
43 | 					        pack<Ts...>{Ts{static_cast<const FBs &&>(std::move(p)).get()}...});
44 | 				};
45 | 				template <typename... Ts, typename... FBs, typename... Bs>
46 | 				constexpr auto f(list_<list_<FBs...>, list_<Ts...>>, pack<Bs...> &&p) {
47 | 					return tail.f(typename Tail::template exec<Ts...>{},
48 | 					              pack<Ts...>{Ts{static_cast<FBs &&>(std::move(p)).get()}...});
49 | 				};
50 | 				template <typename... Ts, typename... FBs, typename... Bs>
51 | 				constexpr auto f(list_<list_<FBs...>, list_<Ts...>>, const pack<Bs...> &p) {
52 | 					return tail.f(typename Tail::template exec<Ts...>{},
53 | 					              pack<Ts...>{Ts{static_cast<const FBs &>(p).get()}...});
54 | 				};
55 | 				template <typename... Ts>
56 | 				using exec = call_<filter_<unpack_<i1_<F>>,
57 | 				                           tee_<listify_,
58 | 				                                transform_<unpack_<i1_<>>,
59 | 				                                           zip_with_index_<lift_<detail::base>>>,
60 | 				                                listify_>>,
61 | 				                   Ts...>;
62 | 			};
63 | 			template <typename F>
64 | 			struct ast<filter_<F, listify_>, listify_> { // break recursion
65 | 				filter_<F, listify_> head;
66 | 				template <typename... Ts, typename... FBs, typename... Bs>
67 | 				constexpr auto f(list_<list_<FBs...>, list_<Ts...>> t, const pack<Bs...> &&p) {
68 | 					return pack<Ts...>{Ts{static_cast<const FBs &&>(p).get()}...};
69 | 				};
70 | 				template <typename... Ts, typename... FBs, typename... Bs>
71 | 				constexpr auto f(list_<list_<FBs...>, list_<Ts...>> t, const pack<Bs...> &p) {
72 | 					return pack<Ts...>{Ts{static_cast<const FBs &>(p).get()}...};
73 | 				};
74 | 				template <typename... Ts>
75 | 				using exec = call_<filter_<unpack_<i1_<F>>,
76 | 				                           tee_<listify_,
77 | 				                                transform_<unpack_<i1_<>>,
78 | 				                                           zip_with_index_<lift_<detail::base>>>,
79 | 				                                listify_>>,
80 | 				                   Ts...>;
81 | 			};
82 | 
83 | 			template <typename F, typename C>
84 | 			struct rebind<filter_<F, C>> {
85 | 				using type = ast<filter_<F, listify_>, typename rebind<C>::type>;
86 | 			};
87 | 
88 | 			template <typename F>
89 | 			struct rebind<filter_<F, listify_>> {
90 | 				using type = ast<filter_<F, listify_>, listify_>;
91 | 			};
92 | 		} // namespace fusion
93 | #endif
94 | 	} // namespace tmp
95 | } // namespace boost
96 | 
97 | #endif


--------------------------------------------------------------------------------
/include/boost/tmp/pack.hpp:
--------------------------------------------------------------------------------
  1 | #ifndef BOOST_TMP_PACK_HPP_INCLUDED
  2 | #define BOOST_TMP_PACK_HPP_INCLUDED
  3 | 
  4 | //  Copyright 2018 Odin Holmes.
  5 | //
  6 | //  Distributed under the Boost Software License, Version 1.0.
  7 | //
  8 | //  See accompanying file LICENSE_1_0.txt or copy at
  9 | //  http://www.boost.org/LICENSE_1_0.txt
 10 | 
 11 | #include "detail/capabilities.hpp"
 12 | #include "detail/dispatch.hpp"
 13 | #include "lift.hpp"
 14 | #include "sequence/zip_with_index.hpp"
 15 | 
 16 | namespace boost {
 17 | 	namespace tmp {
 18 | 		namespace fusion {
 19 | #ifdef BOOST_TMP_CPP14
 20 | 			template <>
 21 | 			struct rebind<listify_> {
 22 | 				using type = listify_;
 23 | 			};
 24 | #endif
 25 | 			template <typename... Bs>
 26 | 			struct pack : Bs... {
 27 | 				constexpr pack(Bs &&... as) : Bs(std::move(as))... {
 28 | 				}
 29 | 			};
 30 | 
 31 | 			namespace detail {
 32 | 				template <typename I, typename T>
 33 | 				struct base {
 34 | 					T data;
 35 | 					using type = T;
 36 | 					constexpr const T &get() const & {
 37 | 						return data;
 38 | 					}
 39 | 					constexpr const T &&get() const && {
 40 | 						return std::move(data);
 41 | 					}
 42 | #ifdef BOOST_TMP_CPP14
 43 | 					constexpr T &&get() && {
 44 | 						return std::move(data);
 45 | 					}
 46 | #endif
 47 | 				};
 48 | 
 49 | 				template <typename I, typename T>
 50 | 				struct base<I, T &&> {
 51 | 					T &&data;
 52 | 					using type = T;
 53 | 					constexpr const T &get() const & {
 54 | 						return data;
 55 | 					}
 56 | 					constexpr const T &&get() const && {
 57 | 						return std::move(data);
 58 | 					}
 59 | #ifdef BOOST_TMP_CPP14
 60 | 					constexpr T &&get() && {
 61 | 						return std::move(data);
 62 | 					}
 63 | #endif
 64 | 				};
 65 | 
 66 | 				template <typename I, typename T>
 67 | 				struct base<I, T &> {
 68 | 					T data;
 69 | 					using type = T;
 70 | 					constexpr const T &get() const {
 71 | 						return data;
 72 | 					}
 73 | 				};
 74 | 				/*
 75 | 				                template <typename... Bs, typename P>
 76 | 				                auto pack_from_bases_r(list_<Bs...>, P &&p) {
 77 | 				                    return fast_pack<Bs...>{static_cast<Bs &&>(p)...};
 78 | 				                };
 79 | 				                template <typename... Bs, typename P>
 80 | 				                auto pack_from_bases_l(list_<Bs...>, P &p) {
 81 | 				                    return fast_pack<Bs...>{static_cast<Bs &>(p)...};
 82 | 				                };*/
 83 | 
 84 | 				template <typename... Ts, typename... Bs, typename... Us>
 85 | 				constexpr fusion::pack<Bs...> pack_impl(list_<Bs...>, Us &&... as) {
 86 | 					return fusion::pack<Bs...>(Bs{std::forward<Us>(as)}...);
 87 | 				};
 88 | 			} // namespace detail
 89 | 		} // namespace fusion
 90 | 
 91 | 		template <typename... Ts>
 92 | 		constexpr auto pack_(Ts &&... args)
 93 | #ifndef BOOST_TMP_CPP14
 94 | 		        -> decltype(fusion::detail::pack_impl(
 95 | 		                call_<zip_with_index_<lift_<fusion::detail::base>>,
 96 | 		                      decltype(std::forward<Ts>(args))...>{},
 97 | 		                std::forward<Ts>(args)...))
 98 | #endif
 99 | 		{
100 | 			return fusion::detail::pack_impl(call_<zip_with_index_<lift_<fusion::detail::base>>,
101 | 			                                       decltype(std::forward<Ts>(args))...>{},
102 | 			                                 std::forward<Ts>(args)...);
103 | 		}
104 | 		template <typename... Ts>
105 | 		constexpr auto val_pack_(Ts... args)
106 | #ifndef BOOST_TMP_CPP14
107 | 		        -> decltype(fusion::detail::pack_impl(
108 | 		                call_<zip_with_index_<lift_<fusion::detail::base>>, Ts...>{},
109 | 		                std::move(args)...))
110 | #endif
111 | 		{
112 | 			return fusion::detail::pack_impl(
113 | 			        call_<zip_with_index_<lift_<fusion::detail::base>>, Ts...>{},
114 | 			        std::move(args)...);
115 | 		}
116 | 
117 | 		// older clang wordaround for empty packs
118 | 		constexpr fusion::pack<> pack_() {
119 | 			return fusion::pack<>{};
120 | 		}
121 | 		constexpr fusion::pack<> val_pack_() {
122 | 			return fusion::pack<>{};
123 | 		}
124 | 		//#endif
125 | 	} // namespace tmp
126 | } // namespace boost
127 | #endif
128 | 


--------------------------------------------------------------------------------
/include/boost/tmp/logic.hpp:
--------------------------------------------------------------------------------
  1 | #ifndef BOOST_TMP_LOGIC_HPP_INCLUDED
  2 | #define BOOST_TMP_LOGIC_HPP_INCLUDED
  3 | 
  4 | //  Copyright 2018 Odin Holmes.
  5 | //
  6 | //  Distributed under the Boost Software License, Version 1.0.
  7 | //
  8 | //  See accompanying file LICENSE_1_0.txt or copy at
  9 | //  http://www.boost.org/LICENSE_1_0.txt
 10 | 
 11 | #include <type_traits>
 12 | #include "algorithm/find_if.hpp"
 13 | #include "call.hpp"
 14 | #include "comparison.hpp"
 15 | #include "vocabulary.hpp"
 16 | 
 17 | namespace boost {
 18 | 	namespace tmp {
 19 | 		template <typename C = identity_>
 20 | 		struct not_ {};
 21 | 		template <typename F = identity_, typename C = identity_>
 22 | 		struct or_ {};
 23 | 		template <typename F = identity_, typename C = identity_>
 24 | 		struct and_ {};
 25 | 
 26 | 		namespace detail {
 27 | 			template <typename C>
 28 | 			struct dispatch<1, not_<C>> {
 29 | 				template <typename T>
 30 | 				using f = typename dispatch<1, C>::template f<bool_<(!T::value)>>;
 31 | 			};
 32 | 
 33 | 			template <bool Short, template <typename...> class F>
 34 | 			struct andy {
 35 | 				template <typename T>
 36 | 				using f                    = andy<(!F<T>::value), F>;
 37 | 				static constexpr int value = -1;
 38 | 			};
 39 | 			template <template <typename...> class F>
 40 | 			struct andy<true, F> {
 41 | 				template <typename T>
 42 | 				using f                    = andy;
 43 | 				static constexpr int value = 1;
 44 | 			};
 45 | 			template <bool Short, template <typename...> class F>
 46 | 			struct ory {
 47 | 				template <typename T>
 48 | 				using f                    = ory<F<T>::value, F>;
 49 | 				static constexpr int value = -1;
 50 | 			};
 51 | 			template <template <typename...> class F>
 52 | 			struct ory<true, F> {
 53 | 				template <typename T>
 54 | 				using f                    = ory;
 55 | 				static constexpr int value = 1;
 56 | 			};
 57 | 
 58 | 			template <unsigned N, template <typename...> class F, typename C>
 59 | 			struct dispatch<N, and_<lift_<F>, C>> {
 60 | 				template <typename... Ts>
 61 | 				using f = typename dispatch<1, C>::template f<
 62 | 				        call_<is_<nothing_>, typename foldey<(select_foldey_loop(sizeof...(
 63 | 				                                     Ts)))>::template f<andy<false, F>, 0, Ts...>>>;
 64 | 			};
 65 | 			template <template <typename...> class F, typename C>
 66 | 			struct dispatch<0, and_<lift_<F>, C>> {
 67 | 				template <typename... Ts>
 68 | 				using f = typename dispatch<1, C>::template f<bool_<false>>;
 69 | 			};
 70 | 			template <unsigned N, typename F, typename C>
 71 | 			struct dispatch<N, and_<F, C>> {
 72 | 				template <typename... Ts>
 73 | 				using f = typename dispatch<1, C>::template f<
 74 | 				        call_<is_<nothing_>,
 75 | 				              typename foldey<(select_foldey_loop(sizeof...(Ts)))>::template f<
 76 | 				                      andy<false, dispatch<1, F>::template f>, 0, Ts...>>>;
 77 | 			};
 78 | 			template <typename F, typename C>
 79 | 			struct dispatch<0, and_<F, C>> {
 80 | 				template <typename... Ts>
 81 | 				using f = typename dispatch<1, C>::template f<bool_<false>>;
 82 | 			};
 83 | 
 84 | 			template <unsigned N, template <typename...> class F, typename C>
 85 | 			struct dispatch<N, or_<lift_<F>, C>> {
 86 | 				template <typename... Ts>
 87 | 				using f = typename dispatch<1, C>::template f<
 88 | 				        call_<is_<nothing_, not_<identity_>>,
 89 | 				              typename foldey<(select_foldey_loop(
 90 | 				                      sizeof...(Ts)))>::template f<ory<false, F>, 0, Ts...>>>;
 91 | 			};
 92 | 			template <template <typename...> class F, typename C>
 93 | 			struct dispatch<0, or_<lift_<F>, C>> {
 94 | 				template <typename... Ts>
 95 | 				using f = typename dispatch<1, C>::template f<bool_<false>>;
 96 | 			};
 97 | 			template <unsigned N, typename F, typename C>
 98 | 			struct dispatch<N, or_<F, C>> {
 99 | 				template <typename... Ts>
100 | 				using f = typename dispatch<1, C>::template f<
101 | 				        call_<is_<nothing_, not_<identity_>>,
102 | 				              typename foldey<(select_foldey_loop(sizeof...(Ts)))>::template f<
103 | 				                      ory<false, dispatch<1, F>::template f>, 0, Ts...>>>;
104 | 			};
105 | 			template <typename F, typename C>
106 | 			struct dispatch<0, or_<F, C>> {
107 | 				template <typename... Ts>
108 | 				using f = typename dispatch<1, C>::template f<bool_<false>>;
109 | 			};
110 | 		} // namespace detail
111 | 	} // namespace tmp
112 | } // namespace boost
113 | #endif
114 | 


--------------------------------------------------------------------------------
/include/boost/tmp/sequence/index.hpp:
--------------------------------------------------------------------------------
  1 | #ifndef BOOST_TMP_INDEX_HPP_INCLUDED
  2 | #define BOOST_TMP_INDEX_HPP_INCLUDED
  3 | 
  4 | //  Copyright 2018 Odin Holmes.
  5 | //
  6 | //  Distributed under the Boost Software License, Version 1.0.
  7 | //
  8 | //  See accompanying file LICENSE_1_0.txt or copy at
  9 | //  http://www.boost.org/LICENSE_1_0.txt
 10 | 
 11 | #include "drop.hpp"
 12 | #include "../identity.hpp"
 13 | #include "../vocabulary.hpp"
 14 | namespace boost {
 15 | 	namespace tmp {
 16 | 		template <typename I, typename C = identity_>
 17 | 		struct index_ {};
 18 | 		template <typename C = identity_>
 19 | 		using front_ = index_<uint_<0>, C>;
 20 | 
 21 | 		template <typename C = identity_>
 22 | 		using i0_ = index_<uint_<0>, C>;
 23 | 		template <typename C = identity_>
 24 | 		using i1_ = index_<uint_<1>, C>;
 25 | 		template <typename C = identity_>
 26 | 		using i2_ = index_<uint_<2>, C>;
 27 | 		template <typename C = identity_>
 28 | 		using i3_ = index_<uint_<3>, C>;
 29 | 		template <typename C = identity_>
 30 | 		using i4_ = index_<uint_<4>, C>;
 31 | 		template <typename C = identity_>
 32 | 		using i5_ = index_<uint_<5>, C>;
 33 | 		template <typename C = identity_>
 34 | 		using i6_ = index_<uint_<6>, C>;
 35 | 		template <typename C = identity_>
 36 | 		using i7_ = index_<uint_<7>, C>;
 37 | 		template <typename C = identity_>
 38 | 		using ui0_ = unpack_<index_<uint_<0>, C>>;
 39 | 		template <typename C = identity_>
 40 | 		using ui1_ = unpack_<index_<uint_<1>, C>>;
 41 | 		template <typename C = identity_>
 42 | 		using ui2_ = unpack_<index_<uint_<2>, C>>;
 43 | 		template <typename C = identity_>
 44 | 		using ui3_ = unpack_<index_<uint_<3>, C>>;
 45 | 		template <typename C = identity_>
 46 | 		using ui4_ = unpack_<index_<uint_<4>, C>>;
 47 | 		template <typename C = identity_>
 48 | 		using ui5_ = unpack_<index_<uint_<5>, C>>;
 49 | 		template <typename C = identity_>
 50 | 		using ui6_ = unpack_<index_<uint_<6>, C>>;
 51 | 		template <typename C = identity_>
 52 | 		using ui7_ = unpack_<index_<uint_<7>, C>>;
 53 | 		namespace detail {
 54 | 			template <unsigned N, typename I, typename C>
 55 | 			struct dispatch<N, index_<I, C>> : dispatch<N, drop_<I, front_<C>>> {};
 56 | 			template <unsigned N, typename C>
 57 | 			struct dispatch<N, index_<nothing_, C>> {
 58 | 				template <typename... Ts>
 59 | 				using f = nothing_;
 60 | 			};
 61 | 			template <unsigned N, typename C>
 62 | 			struct dispatch<N, index_<uint_<0>, C>> {
 63 | 				template <typename T0, typename... Ts>
 64 | 				using f = typename dispatch<1, C>::template f<T0>;
 65 | 			};
 66 | 			template <unsigned N, typename C>
 67 | 			struct dispatch<N, index_<uint_<1>, C>> {
 68 | 				template <typename T0, typename T1, typename... Ts>
 69 | 				using f = typename dispatch<1, C>::template f<T1>;
 70 | 			};
 71 | 			template <unsigned N, typename C>
 72 | 			struct dispatch<N, index_<uint_<2>, C>> {
 73 | 				template <typename T0, typename T1, typename T2, typename... Ts>
 74 | 				using f = typename dispatch<1, C>::template f<T2>;
 75 | 			};
 76 | 			template <unsigned N, typename C>
 77 | 			struct dispatch<N, index_<uint_<3>, C>> {
 78 | 				template <typename T0, typename T1, typename T2, typename T3, typename... Ts>
 79 | 				using f = typename dispatch<1, C>::template f<T3>;
 80 | 			};
 81 | 			template <unsigned N, typename C>
 82 | 			struct dispatch<N, index_<uint_<4>, C>> {
 83 | 				template <typename T0, typename T1, typename T2, typename T3, typename T4,
 84 | 				          typename... Ts>
 85 | 				using f = typename dispatch<1, C>::template f<T4>;
 86 | 			};
 87 | 			template <unsigned N, typename C>
 88 | 			struct dispatch<N, index_<uint_<5>, C>> {
 89 | 				template <typename T0, typename T1, typename T2, typename T3, typename T4,
 90 | 				          typename T5, typename... Ts>
 91 | 				using f = typename dispatch<1, C>::template f<T5>;
 92 | 			};
 93 | 			template <unsigned N, typename C>
 94 | 			struct dispatch<N, index_<uint_<6>, C>> {
 95 | 				template <typename T0, typename T1, typename T2, typename T3, typename T4,
 96 | 				          typename T5, typename T6, typename... Ts>
 97 | 				using f = typename dispatch<1, C>::template f<T6>;
 98 | 			};
 99 | 			template <unsigned N, typename C>
100 | 			struct dispatch<N, index_<uint_<7>, C>> {
101 | 				template <typename T0, typename T1, typename T2, typename T3, typename T4,
102 | 				          typename T5, typename T6, typename T7, typename... Ts>
103 | 				using f = typename dispatch<1, C>::template f<T7>;
104 | 			};
105 | 		} // namespace detail
106 | 	} // namespace tmp
107 | } // namespace boost
108 | 
109 | #endif
110 | 


--------------------------------------------------------------------------------
/include/boost/tmp/algorithm/fold_right.hpp:
--------------------------------------------------------------------------------
  1 | #ifndef BOOST_TMP_FOLD_RIGHT_HPP_INCLUDED
  2 | #define BOOST_TMP_FOLD_RIGHT_HPP_INCLUDED
  3 | 
  4 | //  Copyright 2018 Odin Holmes.
  5 | //
  6 | //  Distributed under the Boost Software License, Version 1.0.
  7 | //
  8 | //  See accompanying file LICENSE_1_0.txt or copy at
  9 | //  http://www.boost.org/LICENSE_1_0.txt
 10 | 
 11 | #include <utility>
 12 | 
 13 | #include "../call.hpp"
 14 | #include "../detail/dispatch.hpp"
 15 | #include "../vocabulary.hpp"
 16 | 
 17 | namespace boost {
 18 | 	namespace tmp {
 19 | 		/// \breif fold right considers the last element in the input pack the initial state, use
 20 | 		/// push_back to add initial state if needed
 21 | 		template <typename F, typename C = identity_>
 22 | 		struct fold_right_ {};
 23 | 
 24 | 		namespace detail {
 25 | 
 26 | 			template <template <typename...> class F, template <typename...> class C>
 27 | 			struct dispatch<0, fold_right_<lift_<F>, lift_<C>>> {
 28 | 				template <typename...>
 29 | 				using f = nothing_;
 30 | 			};
 31 | 
 32 | 			template <template <typename...> class F, template <typename...> class C>
 33 | 			struct dispatch<1, fold_right_<lift_<F>, lift_<C>>> {
 34 | 				template <typename T>
 35 | 				using f = C<T>;
 36 | 			};
 37 | 			template <template <typename...> class F, template <typename...> class C>
 38 | 			struct dispatch<2, fold_right_<lift_<F>, lift_<C>>> {
 39 | 				template <typename T0, typename In>
 40 | 				using f = C<F<In, T0>>;
 41 | 			};
 42 | 			template <template <typename...> class F, template <typename...> class C>
 43 | 			struct dispatch<3, fold_right_<lift_<F>, lift_<C>>> {
 44 | 				template <typename T0, typename T1, typename In>
 45 | 				using f = C<F<F<In, T1>, T0>>;
 46 | 			};
 47 | 			template <template <typename...> class F, template <typename...> class C>
 48 | 			struct dispatch<4, fold_right_<lift_<F>, lift_<C>>> {
 49 | 				template <typename T0, typename T1, typename T2, typename In>
 50 | 				using f = C<F<F<F<In, T2>, T1>, T0>>;
 51 | 			};
 52 | 			template <template <typename...> class F, template <typename...> class C>
 53 | 			struct dispatch<5, fold_right_<lift_<F>, lift_<C>>> {
 54 | 				template <typename T0, typename T1, typename T2, typename T3, typename In>
 55 | 				using f = C<F<F<F<F<In, T3>, T2>, T1>, T0>>;
 56 | 			};
 57 | 			template <template <typename...> class F, template <typename...> class C>
 58 | 			struct dispatch<6, fold_right_<lift_<F>, lift_<C>>> {
 59 | 				template <typename T0, typename T1, typename T2, typename T3, typename T4,
 60 | 				          typename In>
 61 | 				using f = C<F<F<F<F<F<In, T4>, T3>, T2>, T1>, T0>>;
 62 | 			};
 63 | 			template <template <typename...> class F, template <typename...> class C>
 64 | 			struct dispatch<7, fold_right_<lift_<F>, lift_<C>>> {
 65 | 				template <typename T0, typename T1, typename T2, typename T3, typename T4,
 66 | 				          typename T5, typename In>
 67 | 				using f = C<F<F<F<F<F<F<In, T5>, T4>, T3>, T2>, T1>, T0>>;
 68 | 			};
 69 | 			template <template <typename...> class F, template <typename...> class C>
 70 | 			struct dispatch<8, fold_right_<lift_<F>, lift_<C>>> {
 71 | 				template <typename T0, typename T1, typename T2, typename T3, typename T4,
 72 | 				          typename T5, typename T6, typename In>
 73 | 				using f = C<F<F<F<F<F<F<F<In, T6>, T5>, T4>, T3>, T2>, T1>, T0>>;
 74 | 			};
 75 | 			template <unsigned N, template <typename...> class F, template <typename...> class C>
 76 | 			struct dispatch<N, fold_right_<lift_<F>, lift_<C>>> {
 77 | 				template <typename T0, typename T1, typename T2, typename T3, typename T4,
 78 | 				          typename T5, typename T6, typename T7, typename T8, typename... Ts>
 79 | 				using f = C<F<F<F<F<F<F<F<F<F<typename dispatch<find_dispatch(sizeof...(Ts)),
 80 | 				                                                fold_right_<lift_<F>, identity_>>::
 81 | 				                                      template f<Ts...>,
 82 | 				                              T8>,
 83 | 				                            T7>,
 84 | 				                          T6>,
 85 | 				                        T5>,
 86 | 				                      T4>,
 87 | 				                    T3>,
 88 | 				                  T2>,
 89 | 				                T1>,
 90 | 				              T0>>;
 91 | 			};
 92 | 			template <unsigned N, typename F, typename C>
 93 | 			struct dispatch<N, fold_right_<F, C>>
 94 | 			    : dispatch<N, fold_right_<lift_<dispatch<2, F>::template f>,
 95 | 			                              lift_<dispatch<1, C>::template f>>> {};
 96 | 			template <unsigned N, template <typename...> class F, typename C>
 97 | 			struct dispatch<N, fold_right_<lift_<F>, C>>
 98 | 			    : dispatch<N, fold_right_<lift_<F>, lift_<dispatch<1, C>::template f>>> {};
 99 | 			template <unsigned N, typename F, template <typename...> class C>
100 | 			struct dispatch<N, fold_right_<F, lift_<C>>>
101 | 			    : dispatch<N, fold_right_<lift_<dispatch<2, F>::template f>, lift_<C>>> {};
102 | 		} // namespace detail
103 | 	} // namespace tmp
104 | } // namespace boost
105 | #endif
106 | 


--------------------------------------------------------------------------------
/include/boost/tmp/sequence/join.hpp:
--------------------------------------------------------------------------------
  1 | #ifndef BOOST_TMP_JOIN_HPP_INCLUDED
  2 | #define BOOST_TMP_JOIN_HPP_INCLUDED
  3 | 
  4 | //  Copyright 2018 Odin Holmes.
  5 | //
  6 | //  Distributed under the Boost Software License, Version 1.0.
  7 | //
  8 | //  See accompanying file LICENSE_1_0.txt or copy at
  9 | //  http://www.boost.org/LICENSE_1_0.txt
 10 | 
 11 | #include "../detail/dispatch.hpp"
 12 | #include "../sequence/unpack.hpp"
 13 | #include "../vocabulary.hpp"
 14 | 
 15 | namespace boost {
 16 | 	namespace tmp {
 17 | 		template <typename C = listify_>
 18 | 		struct join_ {};
 19 | 		namespace detail {
 20 | 			template <template <typename...> class C, typename...>
 21 | 			struct joiner;
 22 | 			template <template <typename...> class C, typename... T0s, typename... T1s,
 23 | 			          typename... T2s, typename... T3s, typename... T4s, typename... T5s,
 24 | 			          typename... T6s, typename... T7s>
 25 | 			struct joiner<C, list_<T0s...>, list_<T1s...>, list_<T2s...>, list_<T3s...>,
 26 | 			              list_<T4s...>, list_<T5s...>, list_<T6s...>, list_<T7s...>> {
 27 | 				template <typename... Vs>
 28 | 				using f = C<T0s..., T1s..., T2s..., T3s..., T4s..., T5s..., T6s..., T7s..., Vs...>;
 29 | 			};
 30 | 			template <template <typename...> class C, typename... T0s, typename... T1s,
 31 | 			          typename... T2s, typename... T3s, typename... T4s, typename... T5s,
 32 | 			          typename... T6s, typename... T7s, typename... T8s, typename... T9s,
 33 | 			          typename... T10s, typename... T11s, typename... T12s, typename... T13s,
 34 | 			          typename... T14s, typename... T15s, typename... T16s, typename... T17s,
 35 | 			          typename... T18s, typename... T19s, typename... T20s, typename... T21s,
 36 | 			          typename... T22s, typename... T23s, typename... T24s, typename... T25s,
 37 | 			          typename... T26s, typename... T27s, typename... T28s, typename... T29s,
 38 | 			          typename... T30s, typename... T31s>
 39 | 			struct joiner<C, list_<T0s...>, list_<T1s...>, list_<T2s...>, list_<T3s...>,
 40 | 			              list_<T4s...>, list_<T5s...>, list_<T6s...>, list_<T7s...>, list_<T8s...>,
 41 | 			              list_<T9s...>, list_<T10s...>, list_<T11s...>, list_<T12s...>,
 42 | 			              list_<T13s...>, list_<T14s...>, list_<T15s...>, list_<T16s...>,
 43 | 			              list_<T17s...>, list_<T18s...>, list_<T19s...>, list_<T20s...>,
 44 | 			              list_<T21s...>, list_<T22s...>, list_<T23s...>, list_<T24s...>,
 45 | 			              list_<T25s...>, list_<T26s...>, list_<T27s...>, list_<T28s...>,
 46 | 			              list_<T29s...>, list_<T30s...>, list_<T31s...>> {
 47 | 				template <typename... Vs>
 48 | 				using f = C<T0s..., T1s..., T2s..., T3s..., T4s..., T5s..., T6s..., T7s..., T8s...,
 49 | 				            T9s..., T10s..., T11s..., T12s..., T13s..., T14s..., T15s..., T16s...,
 50 | 				            T17s..., T18s..., T19s..., T20s..., T21s..., T22s..., T23s..., T24s...,
 51 | 				            T25s..., T26s..., T27s..., T28s..., T29s..., T30s..., T31s..., Vs...>;
 52 | 			};
 53 | 			template <unsigned N>
 54 | 			struct join_loop;
 55 | 			template <>
 56 | 			struct join_loop<1> {
 57 | 				template <template <typename...> class C, typename T0 = list_<>,
 58 | 				          typename T1 = list_<>, typename T2 = list_<>, typename T3 = list_<>,
 59 | 				          typename T4 = list_<>, typename T5 = list_<>, typename T6 = list_<>,
 60 | 				          typename T7 = list_<>, typename T8 = list_<>, typename T9 = list_<>,
 61 | 				          typename T10 = list_<>, typename T11 = list_<>, typename T12 = list_<>,
 62 | 				          typename T13 = list_<>, typename T14 = list_<>, typename T15 = list_<>,
 63 | 				          typename T16 = list_<>, typename T17 = list_<>, typename T18 = list_<>,
 64 | 				          typename T19 = list_<>, typename T20 = list_<>, typename T21 = list_<>,
 65 | 				          typename T22 = list_<>, typename T23 = list_<>, typename T24 = list_<>,
 66 | 				          typename T25 = list_<>, typename T26 = list_<>, typename T27 = list_<>,
 67 | 				          typename T28 = list_<>, typename T29 = list_<>, typename T30 = list_<>,
 68 | 				          typename T31 = list_<>, typename... Ts>
 69 | 				using f = typename join_loop<(sizeof...(Ts) > 8)>::template f<
 70 | 				        joiner<C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
 71 | 				               T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
 72 | 				               T29, T30, T31>::template f,
 73 | 				        Ts...>;
 74 | 			};
 75 | 			template <>
 76 | 			struct join_loop<0> {
 77 | 				template <template <typename...> class C, typename T0 = list_<>,
 78 | 				          typename T1 = list_<>, typename T2 = list_<>, typename T3 = list_<>,
 79 | 				          typename T4 = list_<>, typename T5 = list_<>, typename T6 = list_<>,
 80 | 				          typename T7 = list_<>, typename T8 = list_<>>
 81 | 				using f = typename joiner<C, T0, T1, T2, T3, T4, T5, T6, T7>::template f<>;
 82 | 			};
 83 | 			template <unsigned N, template <typename...> class C>
 84 | 			struct dispatch<N, join_<lift_<C>>> {
 85 | 				template <typename... Ts>
 86 | 				using f = typename join_loop<(sizeof...(Ts) > 8)>::template f<C, Ts...>;
 87 | 			};
 88 | 
 89 | 			template <unsigned N, typename C>
 90 | 			struct dispatch<N, join_<C>> {
 91 | 				template <typename... Ts>
 92 | 				using f = typename join_loop<(
 93 | 				        sizeof...(Ts) > 8)>::template f<dispatch_unknown<C>::template f, Ts...>;
 94 | 			};
 95 | 		} // namespace detail
 96 | 	} // namespace tmp
 97 | } // namespace boost
 98 | 
 99 | #endif
100 | 


--------------------------------------------------------------------------------
/include/boost/tmp/sequence/drop.hpp:
--------------------------------------------------------------------------------
  1 | #ifndef BOOST_TMP_DROP_HPP_INCLUDED
  2 | #define BOOST_TMP_DROP_HPP_INCLUDED
  3 | 
  4 | //  Copyright 2018 Odin Holmes.
  5 | //
  6 | //  Distributed under the Boost Software License, Version 1.0.
  7 | //
  8 | //  See accompanying file LICENSE_1_0.txt or copy at
  9 | //  http://www.boost.org/LICENSE_1_0.txt
 10 | 
 11 | #include "drop.hpp"
 12 | #include "rotate.hpp"
 13 | #include "../vocabulary.hpp"
 14 | 
 15 | namespace boost {
 16 | 	namespace tmp {
 17 | 		template <typename N = uint_<0>, typename C = listify_>
 18 | 		struct drop_ {};
 19 | 
 20 | 		namespace detail {
 21 | 			constexpr unsigned drop_select(unsigned N) {
 22 | 				return N <= 8 ? N : N < 16 ? 8 : N < 32 ? 16 : N < 64 ? 32 : 64;
 23 | 			}
 24 | 			template <unsigned, typename C>
 25 | 			struct drop_impl;
 26 | 			template <typename C>
 27 | 			struct drop_impl<0, C> {
 28 | 				template <typename... Ts>
 29 | 				using f = call_<C, Ts...>;
 30 | 			};
 31 | 			template <typename C>
 32 | 			struct drop_impl<1, C> {
 33 | 				template <typename T, typename... Ts>
 34 | 				using f = typename dispatch<sizeof...(Ts), C>::template f<Ts...>;
 35 | 			};
 36 | 			template <typename C>
 37 | 			struct drop_impl<2, C> {
 38 | 				template <typename T0, typename T1, typename... Ts>
 39 | 				using f = typename dispatch<sizeof...(Ts), C>::template f<Ts...>;
 40 | 			};
 41 | 			template <typename C>
 42 | 			struct drop_impl<3, C> {
 43 | 				template <typename T0, typename T1, typename T2, typename... Ts>
 44 | 				using f = typename dispatch<sizeof...(Ts), C>::template f<Ts...>;
 45 | 			};
 46 | 			template <typename C>
 47 | 			struct drop_impl<4, C> {
 48 | 				template <typename T0, typename T1, typename T2, typename T3, typename... Ts>
 49 | 				using f = typename dispatch<sizeof...(Ts), C>::template f<Ts...>;
 50 | 			};
 51 | 			template <typename C>
 52 | 			struct drop_impl<5, C> {
 53 | 				template <typename T0, typename T1, typename T2, typename T3, typename T4,
 54 | 				          typename... Ts>
 55 | 				using f = typename dispatch<sizeof...(Ts), C>::template f<Ts...>;
 56 | 			};
 57 | 			template <typename C>
 58 | 			struct drop_impl<6, C> {
 59 | 				template <typename T0, typename T1, typename T2, typename T3, typename T4,
 60 | 				          typename T5, typename... Ts>
 61 | 				using f = typename dispatch<sizeof...(Ts), C>::template f<Ts...>;
 62 | 			};
 63 | 			template <typename C>
 64 | 			struct drop_impl<7, C> {
 65 | 				template <typename T0, typename T1, typename T2, typename T3, typename T4,
 66 | 				          typename T5, typename T6, typename... Ts>
 67 | 				using f = typename dispatch<sizeof...(Ts), C>::template f<Ts...>;
 68 | 			};
 69 | 			template <typename C>
 70 | 			struct drop_impl<8, C> {
 71 | 				template <typename T0, typename T1, typename T2, typename T3, typename T4,
 72 | 				          typename T5, typename T6, typename T7, typename... Ts>
 73 | 				using f = typename dispatch<sizeof...(Ts), C>::template f<Ts...>;
 74 | 			};
 75 | 			template <typename C>
 76 | 			struct drop_impl<16, C> {
 77 | 				template <typename T0, typename T1, typename T2, typename T3, typename T4,
 78 | 				          typename T5, typename T6, typename T7, typename T8, typename T9,
 79 | 				          typename T10, typename T11, typename T12, typename T13, typename T14,
 80 | 				          typename T15, typename... Ts>
 81 | 				using f = typename dispatch<sizeof...(Ts), C>::template f<Ts...>;
 82 | 			};
 83 | 			template <typename C>
 84 | 			struct drop_impl<32, C> {
 85 | 				template <typename T0, typename T1, typename T2, typename T3, typename T4,
 86 | 				          typename T5, typename T6, typename T7, typename T8, typename T9,
 87 | 				          typename T10, typename T11, typename T12, typename T13, typename T14,
 88 | 				          typename T15, typename T16, typename T17, typename T18, typename T19,
 89 | 				          typename T20, typename T21, typename T22, typename T23, typename T24,
 90 | 				          typename T25, typename T26, typename T27, typename T28, typename T29,
 91 | 				          typename T30, typename T31, typename... Ts>
 92 | 				using f = typename dispatch<sizeof...(Ts), C>::template f<Ts...>;
 93 | 			};
 94 | 			template <typename C>
 95 | 			struct drop_impl<64, C> {
 96 | 				template <typename T0, typename T1, typename T2, typename T3, typename T4,
 97 | 				          typename T5, typename T6, typename T7, typename T8, typename T9,
 98 | 				          typename T10, typename T11, typename T12, typename T13, typename T14,
 99 | 				          typename T15, typename T16, typename T17, typename T18, typename T19,
100 | 				          typename T20, typename T21, typename T22, typename T23, typename T24,
101 | 				          typename T25, typename T26, typename T27, typename T28, typename T29,
102 | 				          typename T30, typename T31, typename T32, typename T33, typename T34,
103 | 				          typename T35, typename T36, typename T37, typename T38, typename T39,
104 | 				          typename T40, typename T41, typename T42, typename T43, typename T44,
105 | 				          typename T45, typename T46, typename T47, typename T48, typename T49,
106 | 				          typename T50, typename T51, typename T52, typename T53, typename T54,
107 | 				          typename T55, typename T56, typename T57, typename T58, typename T59,
108 | 				          typename T60, typename T61, typename T62, typename T63, typename... Ts>
109 | 				using f = typename dispatch<sizeof...(Ts), C>::template f<Ts...>;
110 | 			};
111 | 
112 | 			template <unsigned P, typename C, unsigned Step = drop_select(P)>
113 | 			struct make_drop : drop_impl<Step, drop_<uint_<(P - Step)>, C>> { /* not done */
114 | 			};
115 | 			template <unsigned P, typename C>
116 | 			struct make_drop<P, C, P> : drop_impl<P, C> {};
117 | 
118 | 			template <unsigned N, typename P, typename C>
119 | 			struct dispatch<N, drop_<P, C>> : make_drop<P::value, C> {};
120 | 		} // namespace detail
121 | 	} // namespace tmp
122 | } // namespace boost
123 | 
124 | #endif


--------------------------------------------------------------------------------
/include/boost/tmp/sequence/rotate.hpp:
--------------------------------------------------------------------------------
  1 | #ifndef BOOST_TMP_ROTATE_HPP_INCLUDED
  2 | #define BOOST_TMP_ROTATE_HPP_INCLUDED
  3 | 
  4 | //  Copyright 2018 Odin Holmes.
  5 | //
  6 | //  Distributed under the Boost Software License, Version 1.0.
  7 | //
  8 | //  See accompanying file LICENSE_1_0.txt or copy at
  9 | //  http://www.boost.org/LICENSE_1_0.txt
 10 | 
 11 | #include "../vocabulary.hpp"
 12 | 
 13 | namespace boost {
 14 | 	namespace tmp {
 15 | 		template <typename N = uint_<0>, typename C = listify_>
 16 | 		struct rotate_ {};
 17 | 
 18 | 		namespace detail {
 19 | 			constexpr unsigned rotate_select(unsigned N) {
 20 | 				return N <= 8 ? N : N < 16 ? 8 : N < 32 ? 16 : N < 64 ? 32 : 64;
 21 | 			}
 22 | 			template <unsigned, typename C>
 23 | 			struct rotate_impl;
 24 | 			template <typename C>
 25 | 			struct rotate_impl<0, C> {
 26 | 				template <typename... Ts>
 27 | 				using f = typename dispatch<find_dispatch(sizeof...(Ts)), C>::template f<Ts...>;
 28 | 			};
 29 | 			template <typename C>
 30 | 			struct rotate_impl<1, C> {
 31 | 				template <typename T, typename... Ts>
 32 | 				using f = typename dispatch<find_dispatch(sizeof...(Ts) + 1), C>::template f<Ts...,
 33 | 				                                                                             T>;
 34 | 			};
 35 | 			template <typename C>
 36 | 			struct rotate_impl<2, C> {
 37 | 				template <typename T0, typename T1, typename... Ts>
 38 | 				using f = typename dispatch<find_dispatch(sizeof...(Ts) + 2),
 39 | 				                            C>::template f<Ts..., T0, T1>;
 40 | 			};
 41 | 			template <typename C>
 42 | 			struct rotate_impl<3, C> {
 43 | 				template <typename T0, typename T1, typename T2, typename... Ts>
 44 | 				using f = typename dispatch<find_dispatch(sizeof...(Ts) + 3),
 45 | 				                            C>::template f<Ts..., T0, T1, T2>;
 46 | 			};
 47 | 			template <typename C>
 48 | 			struct rotate_impl<4, C> {
 49 | 				template <typename T0, typename T1, typename T2, typename T3, typename... Ts>
 50 | 				using f = typename dispatch<find_dispatch(sizeof...(Ts) + 4),
 51 | 				                            C>::template f<Ts..., T0, T1, T2, T3>;
 52 | 			};
 53 | 			template <typename C>
 54 | 			struct rotate_impl<5, C> {
 55 | 				template <typename T0, typename T1, typename T2, typename T3, typename T4,
 56 | 				          typename... Ts>
 57 | 				using f = typename dispatch<find_dispatch(sizeof...(Ts) + 5),
 58 | 				                            C>::template f<Ts..., T0, T1, T2, T3, T4>;
 59 | 			};
 60 | 			template <typename C>
 61 | 			struct rotate_impl<6, C> {
 62 | 				template <typename T0, typename T1, typename T2, typename T3, typename T4,
 63 | 				          typename T5, typename... Ts>
 64 | 				using f = typename dispatch<find_dispatch(sizeof...(Ts) + 6),
 65 | 				                            C>::template f<Ts..., T0, T1, T2, T3, T4, T5>;
 66 | 			};
 67 | 			template <typename C>
 68 | 			struct rotate_impl<7, C> {
 69 | 				template <typename T0, typename T1, typename T2, typename T3, typename T4,
 70 | 				          typename T5, typename T6, typename... Ts>
 71 | 				using f = typename dispatch<find_dispatch(sizeof...(Ts) + 7),
 72 | 				                            C>::template f<Ts..., T0, T1, T2, T3, T4, T5, T6>;
 73 | 			};
 74 | 			template <typename C>
 75 | 			struct rotate_impl<8, C> {
 76 | 				template <typename T0, typename T1, typename T2, typename T3, typename T4,
 77 | 				          typename T5, typename T6, typename T7, typename... Ts>
 78 | 				using f = typename dispatch<find_dispatch(sizeof...(Ts) + 8),
 79 | 				                            C>::template f<Ts..., T0, T1, T2, T3, T4, T5, T6, T7>;
 80 | 			};
 81 | 			template <typename C>
 82 | 			struct rotate_impl<16, C> {
 83 | 				template <typename T0, typename T1, typename T2, typename T3, typename T4,
 84 | 				          typename T5, typename T6, typename T7, typename T8, typename T9,
 85 | 				          typename T10, typename T11, typename T12, typename T13, typename T14,
 86 | 				          typename T15, typename... Ts>
 87 | 				using f = typename dispatch<find_dispatch(sizeof...(Ts) + 16),
 88 | 				                            C>::template f<Ts..., T0, T1, T2, T3, T4, T5, T6, T7,
 89 | 				                                           T8, T9, T10, T11, T12, T13, T14, T15>;
 90 | 			};
 91 | 			template <typename C>
 92 | 			struct rotate_impl<32, C> {
 93 | 				template <typename T0, typename T1, typename T2, typename T3, typename T4,
 94 | 				          typename T5, typename T6, typename T7, typename T8, typename T9,
 95 | 				          typename T10, typename T11, typename T12, typename T13, typename T14,
 96 | 				          typename T15, typename T16, typename T17, typename T18, typename T19,
 97 | 				          typename T20, typename T21, typename T22, typename T23, typename T24,
 98 | 				          typename T25, typename T26, typename T27, typename T28, typename T29,
 99 | 				          typename T30, typename T31, typename... Ts>
100 | 				using f = typename dispatch<find_dispatch(sizeof...(Ts) + 32), C>::template f<
101 | 				        Ts..., T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
102 | 				        T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
103 | 				        T31>;
104 | 			};
105 | 			template <typename C>
106 | 			struct rotate_impl<64, C> {
107 | 				template <typename T0, typename T1, typename T2, typename T3, typename T4,
108 | 				          typename T5, typename T6, typename T7, typename T8, typename T9,
109 | 				          typename T10, typename T11, typename T12, typename T13, typename T14,
110 | 				          typename T15, typename T16, typename T17, typename T18, typename T19,
111 | 				          typename T20, typename T21, typename T22, typename T23, typename T24,
112 | 				          typename T25, typename T26, typename T27, typename T28, typename T29,
113 | 				          typename T30, typename T31, typename T32, typename T33, typename T34,
114 | 				          typename T35, typename T36, typename T37, typename T38, typename T39,
115 | 				          typename T40, typename T41, typename T42, typename T43, typename T44,
116 | 				          typename T45, typename T46, typename T47, typename T48, typename T49,
117 | 				          typename T50, typename T51, typename T52, typename T53, typename T54,
118 | 				          typename T55, typename T56, typename T57, typename T58, typename T59,
119 | 				          typename T60, typename T61, typename T62, typename T63, typename... Ts>
120 | 				using f = typename dispatch<find_dispatch(sizeof...(Ts) + 64), C>::template f<
121 | 				        Ts..., T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
122 | 				        T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
123 | 				        T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45,
124 | 				        T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60,
125 | 				        T61, T62, T63>;
126 | 			};
127 | 			template <typename P, typename C>
128 | 			struct dispatch<0, rotate_<P, C>> {
129 | 				template <typename...>
130 | 				using f = typename dispatch<0, C>::template f<>;
131 | 			};
132 | 			template <unsigned P, typename C, unsigned Step = rotate_select(P)>
133 | 			struct make_rotate
134 | 			    : rotate_impl<rotate_select(Step), rotate_<uint_<(P - Step)>, C>> { /* not done */
135 | 			};
136 | 			template <unsigned P, typename C>
137 | 			struct make_rotate<P, C, P> : rotate_impl<P, C> {};
138 | 
139 | 			template <unsigned N, typename P, typename C>
140 | 			struct dispatch<N, rotate_<P, C>> : make_rotate<P::value, C> {};
141 | 		} // namespace detail
142 | 	} // namespace tmp
143 | } // namespace boost
144 | 
145 | #endif


--------------------------------------------------------------------------------
/include/boost/tmp/algorithm/sort.hpp:
--------------------------------------------------------------------------------
  1 | #ifndef BOOST_TMP_SORT_HPP_INCLUDED
  2 | #define BOOST_TMP_SORT_HPP_INCLUDED
  3 | 
  4 | //  Copyright 2018 Odin Holmes.
  5 | //
  6 | //  Distributed under the Boost Software License, Version 1.0.
  7 | //
  8 | //  See accompanying file LICENSE_1_0.txt or copy at
  9 | //  http://www.boost.org/LICENSE_1_0.txt
 10 | 
 11 | #include "../comparison.hpp"
 12 | #include "../detail/capabilities.hpp"
 13 | #include "../sequence/push_front.hpp"
 14 | #include "../sequence/take.hpp"
 15 | #include "../vocabulary.hpp"
 16 | namespace boost {
 17 | 	namespace tmp {
 18 | 		template <typename F = less_<>, typename C = listify_>
 19 | 		struct sort_ {};
 20 | 
 21 | 		namespace detail {
 22 | 			namespace btree {
 23 | 				template <typename... Ts>
 24 | 				struct blist {};
 25 | 				template <typename L, typename E, typename R>
 26 | 				struct bnode {};
 27 | 				template <typename T>
 28 | 				struct bun;
 29 | 				template <bool, template <typename...> class F>
 30 | 				struct bpush;
 31 | 				template <template <typename...> class F>
 32 | 				struct bpush<false, F> {
 33 | 					template <typename T, typename L, typename E, typename R>
 34 | 					using n = bnode<L, E, typename bun<R>::template f<F, T>>;
 35 | 					template <typename T, typename LL, typename LE, typename LR, typename E,
 36 | 					          typename RL, typename RE, typename RR>
 37 | 					using nn = typename bpush<F<T, RE>::value, F>::template nn_0<T, LL, LE, LR, E,
 38 | 					                                                             RL, RE, RR>;
 39 | 					template <typename T, typename LL, typename LE, typename LR, typename E,
 40 | 					          typename RL, typename RE, typename RR>
 41 | 					using nn_0 = bnode<bnode<bnode<LL, LE, LR>, E, RL>, RE,
 42 | 					                   typename bun<RR>::template f<F, T>>;
 43 | 					template <typename T, typename LL, typename LE, typename LR, typename E,
 44 | 					          typename RL, typename RE, typename RR>
 45 | 					using nn_1 = bnode<bnode<LL, LE, typename bun<LR>::template f<F, T>>, E,
 46 | 					                   bnode<RL, RE, RR>>;
 47 | 					template <typename T, typename E>
 48 | 					using l1 = blist<E, T>;
 49 | 					template <typename T, typename E0, typename E1>
 50 | 					using l2_0 = typename bpush<F<T, E1>::value, F>::template l2_1<T, E0, E1>;
 51 | 					template <typename T, typename E0, typename E1>
 52 | 					using l2_1 = bnode<blist<E0>, E1, blist<T>>;
 53 | 				};
 54 | 				template <template <typename...> class F>
 55 | 				struct bpush<true, F> {
 56 | 					template <typename T, typename L, typename E, typename R>
 57 | 					using n = bnode<typename bun<L>::template f<F, T>, E, R>;
 58 | 					template <typename T, typename LL, typename LE, typename LR, typename E,
 59 | 					          typename RL, typename RE, typename RR>
 60 | 					using nn = typename bpush<F<T, LE>::value, F>::template nn_1<T, LL, LE, LR, E,
 61 | 					                                                             RL, RE, RR>;
 62 | 					template <typename T, typename LL, typename LE, typename LR, typename E,
 63 | 					          typename RL, typename RE, typename RR>
 64 | 					using nn_0 = bnode<bnode<LL, LE, LR>, E,
 65 | 					                   bnode<typename bun<RL>::template f<F, T>, RE, RR>>;
 66 | 					template <typename T, typename LL, typename LE, typename LR, typename E,
 67 | 					          typename RL, typename RE, typename RR>
 68 | 					using nn_1 = bnode<typename bun<LL>::template f<F, T>, LE,
 69 | 					                   bnode<LR, E, bnode<RL, RE, RR>>>;
 70 | 					template <typename T, typename E>
 71 | 					using l1 = blist<T, E>;
 72 | 					template <typename T, typename E0, typename E1>
 73 | 					using l2_0 = bnode<blist<T>, E0, blist<E1>>;
 74 | 					template <typename T, typename E0, typename E1>
 75 | 					using l2_1 = bnode<blist<E0>, T, blist<E1>>;
 76 | 				};
 77 | 
 78 | 				template <>
 79 | 				struct bun<blist<>> {
 80 | 					template <template <typename...> class F, typename T>
 81 | 					using f = blist<T>;
 82 | 				};
 83 | 				template <typename E>
 84 | 				struct bun<blist<E>> {
 85 | 					template <template <typename...> class F, typename T>
 86 | 					using f = typename bpush<F<T, E>::value, F>::template l1<T, E>;
 87 | 				};
 88 | 				template <typename E0, typename E1>
 89 | 				struct bun<blist<E0, E1>> {
 90 | 					template <template <typename...> class F, typename T>
 91 | 					using f = typename bpush<F<T, E0>::value, F>::template l2_0<T, E0, E1>;
 92 | 				};
 93 | 				template <typename L, typename E, typename R>
 94 | 				struct bun<bnode<L, E, R>> {
 95 | 					template <template <typename...> class F, typename T>
 96 | 					using f = typename bpush<F<T, E>::value, F>::template n<T, L, E, R>;
 97 | 				};
 98 | 				template <typename LL, typename LE, typename LR, typename E, typename RL,
 99 | 				          typename RE, typename RR>
100 | 				struct bun<bnode<bnode<LL, LE, LR>, E, bnode<RL, RE, RR>>> {
101 | 					template <template <typename...> class F, typename T>
102 | 					using f = typename bpush<F<T, E>::value, F>::template nn<T, LL, LE, LR, E, RL,
103 | 					                                                         RE, RR>;
104 | 				};
105 | 				template <typename LLL, typename LLE, typename LLR, typename LE, typename LR,
106 | 				          typename E, typename... Ts>
107 | 				struct bun<bnode<bnode<bnode<LLL, LLE, LLR>, LE, LR>, E, blist<Ts...>>> {
108 | 					template <template <typename...> class F, typename T>
109 | 					using f = typename bpush<F<T, LE>::value, F>::template nn<T, LLL, LLE, LLR, LE,
110 | 					                                                          LR, E, blist<Ts...>>;
111 | 				};
112 | 
113 | 				template <typename... Ts, typename E, typename RL, typename RE, typename RRL,
114 | 				          typename RRE, typename RRR>
115 | 				struct bun<bnode<blist<Ts...>, E, bnode<RL, RE, bnode<RRL, RRE, RRR>>>> {
116 | 					template <template <typename...> class F, typename T>
117 | 					using f =
118 | 					        typename bpush<F<T, RE>::value, F>::template nn<T, blist<Ts...>, E, RL,
119 | 					                                                        RE, RRL, RRE, RRR>;
120 | 				};
121 | 
122 | 				template <typename LL, typename LE, typename LR, typename E, typename RL,
123 | 				          typename RE, typename RR>
124 | 				struct join7;
125 | 
126 | 				template <typename... LL, typename LE, typename... LR, typename E, typename... RL,
127 | 				          typename RE, typename... RR>
128 | 				struct join7<blist<LL...>, LE, blist<LR...>, E, blist<RL...>, RE, blist<RR...>> {
129 | 					using type = blist<LL..., LE, LR..., E, RL..., RE, RR...>;
130 | 				};
131 | 
132 | 				template <typename T>
133 | 				struct bflat;
134 | 
135 | 				template <typename L, typename E, typename R>
136 | 				struct bflat<bnode<L, E, R>> {
137 | 					using type = typename bflat<
138 | 					        bnode<typename bflat<L>::type, E, typename bflat<R>::type>>::type;
139 | 				};
140 | 				template <typename LL, typename LE, typename LR, typename E, typename RL,
141 | 				          typename RE, typename RR>
142 | 				struct bflat<bnode<bnode<LL, LE, LR>, E, bnode<RL, RE, RR>>> {
143 | 					using type =
144 | 					        typename join7<typename bflat<LL>::type, LE, typename bflat<LR>::type,
145 | 					                       E, typename bflat<RL>::type, RE,
146 | 					                       typename bflat<RR>::type>::type;
147 | 				};
148 | 
149 | 				template <typename... L, typename E, typename... R>
150 | 				struct bflat<bnode<blist<L...>, E, blist<R...>>> {
151 | 					using type = blist<L..., E, R...>;
152 | 				};
153 | 				template <typename... T>
154 | 				struct bflat<blist<T...>> {
155 | 					using type = blist<T...>;
156 | 				};
157 | 
158 | 				template <typename T>
159 | 				using collapse_t = typename btree::bflat<T>::type;
160 | 			} // namespace btree
161 | 
162 | 			template <typename F>
163 | 			struct element_pusher {};
164 | 			template <typename F>
165 | 			struct dispatch<2, element_pusher<F>> {
166 | 				template <typename T, typename U>
167 | 				using f = typename btree::bun<T>::template f<dispatch<2, F>::template f, U>;
168 | 			};
169 | 			template <template <typename...> class F>
170 | 			struct dispatch<2, element_pusher<lift_<F>>> {
171 | 				template <typename T, typename U>
172 | 				using f = typename btree::bun<T>::template f<F, U>;
173 | 			};
174 | 
175 | 			template <template <typename...> class F>
176 | 			struct pusher {
177 | 				template <typename T, typename U>
178 | 				using f = typename btree::bun<T>::template f<F, U>;
179 | 			};
180 | 
181 | 			template <template <typename...> class F, typename C = identity_,
182 | 			          typename Initial = btree::blist<>>
183 | 			using make_binary_tree =
184 | 			        push_front_<Initial, fold_left_<lift_<pusher<F>::template f>, C>>;
185 | 
186 | 			template <typename C>
187 | 			using collapse_unpack = lift_<btree::collapse_t, unpack_<C>>;
188 | 
189 | 			template <unsigned N, template <typename...> class F, typename C>
190 | 			struct dispatch<N, sort_<lift_<F>, C>>
191 | 			    : dispatch<N, make_binary_tree<F, collapse_unpack<C>, btree::blist<>>> {};
192 | 
193 | 			template <unsigned N, typename F, typename C>
194 | 			struct dispatch<N, sort_<F, C>>
195 | 			    : dispatch<N, make_binary_tree<dispatch<2, F>::template f, collapse_unpack<C>,
196 | 			                                   btree::blist<>>> {};
197 | 
198 | 		} // namespace detail
199 | 	} // namespace tmp
200 | } // namespace boost
201 | 
202 | #endif


--------------------------------------------------------------------------------
/include/boost/tmp/sequence/tee.hpp:
--------------------------------------------------------------------------------
  1 | #ifndef BOOST_TMP_tee_HPP_INCLUDED
  2 | #define BOOST_TMP_tee_HPP_INCLUDED
  3 | 
  4 | //  Copyright 2018 Odin Holmes.
  5 | //
  6 | //  Distributed under the Boost Software License, Version 1.0.
  7 | //
  8 | //  See accompanying file LICENSE_1_0.txt or copy at
  9 | //  http://www.boost.org/LICENSE_1_0.txt
 10 | 
 11 | #include "push_front.hpp"
 12 | #include "rotate.hpp"
 13 | #include "../detail/dispatch.hpp"
 14 | #include "../logic.hpp"
 15 | #include "../vocabulary.hpp"
 16 | namespace boost {
 17 | 	namespace tmp {
 18 | 		template <typename... Fs>
 19 | 		struct tee_ {};
 20 | 		namespace detail {
 21 | 			template <typename N, typename L, typename C, typename... Fs>
 22 | 			struct tee_impl {
 23 | 				template <typename... Ts>
 24 | 				using f = typename dispatch<find_dispatch(sizeof...(Fs) + 1), C>::template f<
 25 | 				        typename dispatch<find_dispatch(sizeof...(Ts)), Fs>::template f<Ts...>...,
 26 | 				        typename dispatch<find_dispatch(sizeof...(Ts)), L>::template f<Ts...>>;
 27 | 			};
 28 | 			// specialization for case where last closure is a forward
 29 | 			template <typename N, typename C, typename... Fs>
 30 | 			struct tee_impl<N, identity_, C, Fs...> {
 31 | 				template <typename... Ts>
 32 | 				using f = typename dispatch<find_dispatch(sizeof...(Fs) + sizeof...(Ts)), C>::
 33 | 				        template f<typename dispatch<find_dispatch(sizeof...(Ts)),
 34 | 				                                     Fs>::template f<Ts...>...,
 35 | 				                   Ts...>;
 36 | 			};
 37 | 			template <typename L, typename C, typename... Fs>
 38 | 			struct tee_impl<uint_<1>, L, C, Fs...> {
 39 | 				template <typename T0>
 40 | 				using f = typename dispatch<find_dispatch(sizeof...(Fs) + 1), C>::template f<
 41 | 				        typename dispatch<1, Fs>::template f<T0>...,
 42 | 				        typename dispatch<1, L>::template f<T0>>;
 43 | 			};
 44 | 			// specialization for case where last closure is a forward
 45 | 			template <typename C, typename... Fs>
 46 | 			struct tee_impl<uint_<1>, identity_, C, Fs...> {
 47 | 				template <typename T0>
 48 | 				using f = typename dispatch<find_dispatch(sizeof...(Fs) + 1), C>::template f<
 49 | 				        typename dispatch<1, Fs>::template f<T0>..., T0>;
 50 | 			};
 51 | 			template <typename L, typename C, typename... Fs>
 52 | 			struct tee_impl<uint_<2>, L, C, Fs...> {
 53 | 				template <typename T0, typename T1>
 54 | 				using f = typename dispatch<find_dispatch(sizeof...(Fs) + 1), C>::template f<
 55 | 				        typename dispatch<2, Fs>::template f<T0, T1>...,
 56 | 				        typename dispatch<2, L>::template f<T0, T1>>;
 57 | 			};
 58 | 			// specialization for case where last closure is a forward
 59 | 			template <typename C, typename... Fs>
 60 | 			struct tee_impl<uint_<2>, identity_, C, Fs...> {
 61 | 				template <typename T0, typename T1>
 62 | 				using f = typename dispatch<find_dispatch(sizeof...(Fs) + 2), C>::template f<
 63 | 				        typename dispatch<2, Fs>::template f<T0, T1>..., T0, T1>;
 64 | 			};
 65 | 
 66 | 			// in case the continuation is an and_
 67 | 
 68 | 			template <bool b, typename C, typename... Fs>
 69 | 			struct tee_and_impl;
 70 | 			template <typename C, typename... Fs>
 71 | 			struct tee_and_impl<false, C, Fs...> {
 72 | 				template <typename... Ts>
 73 | 				using f = typename dispatch<1, C>::template f<false_>;
 74 | 			};
 75 | 			template <typename C, typename... Fs>
 76 | 			struct tee_and_impl<true, C, Fs...> {
 77 | 				template <typename... Ts>
 78 | 				using f = typename dispatch<1, C>::template f<true_>;
 79 | 			};
 80 | 			template <typename C, typename F, typename... Fs>
 81 | 			struct tee_and_impl<true, C, F, Fs...> {
 82 | 				template <typename... Ts>
 83 | 				using f = typename tee_and_impl<
 84 | 				        dispatch<find_dispatch(sizeof...(Ts)), F>::template f<Ts...>::value, C,
 85 | 				        Fs...>::template f<Ts...>;
 86 | 			};
 87 | 			template <bool b, typename C, typename... Fs>
 88 | 			struct tee_and_impl_1;
 89 | 			template <typename C, typename... Fs>
 90 | 			struct tee_and_impl_1<false, C, Fs...> {
 91 | 				template <typename T0>
 92 | 				using f = typename dispatch<1, C>::template f<false_>;
 93 | 			};
 94 | 			template <typename C, typename... Fs>
 95 | 			struct tee_and_impl_1<true, C, Fs...> {
 96 | 				template <typename T0>
 97 | 				using f1 = typename dispatch<1, C>::template f<true_>;
 98 | 			};
 99 | 			template <typename C, typename F, typename... Fs>
100 | 			struct tee_and_impl_1<true, C, F, Fs...> {
101 | 				template <typename T0>
102 | 				using f = typename tee_and_impl<dispatch<1, F>::template f<T0>::value, C,
103 | 				                                Fs...>::template f<T0>;
104 | 			};
105 | 			template <bool b, typename C, typename... Fs>
106 | 			struct tee_and_impl_2;
107 | 			template <typename C, typename... Fs>
108 | 			struct tee_and_impl_2<false, C, Fs...> {
109 | 				template <typename T0, typename T1>
110 | 				using f = typename dispatch<1, C>::template f<false_>;
111 | 			};
112 | 			template <typename C, typename... Fs>
113 | 			struct tee_and_impl_2<true, C, Fs...> {
114 | 				template <typename T0, typename T1>
115 | 				using f = typename dispatch<1, C>::template f<true_>;
116 | 			};
117 | 			template <typename C, typename F, typename... Fs>
118 | 			struct tee_and_impl_2<true, C, F, Fs...> {
119 | 				template <typename T0, typename T1>
120 | 				using f = typename tee_and_impl<dispatch<2, F>::template f<T0, T1>::value, C,
121 | 				                                Fs...>::template f<T0, T1>;
122 | 			};
123 | 
124 | 			template <typename N, typename L, typename C, typename... Fs>
125 | 			struct tee_impl<N, L, and_<identity_, C>, Fs...> : tee_and_impl<true, C, Fs..., L> {};
126 | 			template <typename L, typename C, typename... Fs>
127 | 			struct tee_impl<uint_<1>, L, and_<identity_, C>, Fs...>
128 | 			    : tee_and_impl_1<true, C, Fs..., L> {};
129 | 			template <typename C, typename... Fs>
130 | 			struct tee_impl<uint_<1>, identity_, and_<identity_, C>, Fs...>
131 | 			    : tee_and_impl_1<true, C, Fs..., identity_> {};
132 | 			template <typename L, typename C, typename... Fs>
133 | 			struct tee_impl<uint_<2>, L, and_<identity_, C>, Fs...>
134 | 			    : tee_and_impl_2<true, C, Fs..., L> {};
135 | 
136 | 			// in case the continuation is an or_
137 | 
138 | 			template <bool b, typename C, typename... Fs>
139 | 			struct tee_or_impl;
140 | 			template <typename C, typename... Fs>
141 | 			struct tee_or_impl<true, C, Fs...> {
142 | 				template <typename... Ts>
143 | 				using f = typename dispatch<1, C>::template f<true_>;
144 | 			};
145 | 			template <typename C, typename... Fs>
146 | 			struct tee_or_impl<false, C, Fs...> {
147 | 				template <typename... Ts>
148 | 				using f = typename dispatch<1, C>::template f<false_>;
149 | 			};
150 | 			template <typename C, typename F, typename... Fs>
151 | 			struct tee_or_impl<false, C, F, Fs...> {
152 | 				template <typename... Ts>
153 | 				using f = typename tee_or_impl<
154 | 				        dispatch<find_dispatch(sizeof...(Ts)), F>::template f<Ts...>::value, C,
155 | 				        Fs...>::template f<Ts...>;
156 | 			};
157 | 			template <bool b, typename C, typename... Fs>
158 | 			struct tee_or_impl_1;
159 | 			template <typename C, typename... Fs>
160 | 			struct tee_or_impl_1<true, C, Fs...> {
161 | 				template <typename T0>
162 | 				using f = typename dispatch<1, C>::template f<true_>;
163 | 			};
164 | 			template <typename C, typename... Fs>
165 | 			struct tee_or_impl_1<false, C, Fs...> {
166 | 				template <typename T0>
167 | 				using f1 = typename dispatch<1, C>::template f<false_>;
168 | 			};
169 | 			template <typename C, typename F, typename... Fs>
170 | 			struct tee_or_impl_1<false, C, F, Fs...> {
171 | 				template <typename T0>
172 | 				using f = typename tee_or_impl<dispatch<1, F>::template f<T0>::value, C,
173 | 				                               Fs...>::template f<T0>;
174 | 			};
175 | 			template <bool b, typename C, typename... Fs>
176 | 			struct tee_or_impl_2;
177 | 			template <typename C, typename... Fs>
178 | 			struct tee_or_impl_2<true, C, Fs...> {
179 | 				template <typename T0, typename T1>
180 | 				using f = typename dispatch<1, C>::template f<true_>;
181 | 			};
182 | 			template <typename C, typename... Fs>
183 | 			struct tee_or_impl_2<false, C, Fs...> {
184 | 				template <typename T0, typename T1>
185 | 				using f = typename dispatch<1, C>::template f<false_>;
186 | 			};
187 | 			template <typename C, typename F, typename... Fs>
188 | 			struct tee_or_impl_2<false, C, F, Fs...> {
189 | 				template <typename T0, typename T1>
190 | 				using f = typename tee_or_impl<dispatch<2, F>::template f<T0, T1>::value, C,
191 | 				                               Fs...>::template f<T0, T1>;
192 | 			};
193 | 
194 | 			template <typename N, typename L, typename C, typename... Fs>
195 | 			struct tee_impl<N, L, or_<identity_, C>, Fs...> : tee_or_impl<false, C, Fs..., L> {};
196 | 			template <typename L, typename C, typename... Fs>
197 | 			struct tee_impl<uint_<1>, L, or_<identity_, C>, Fs...>
198 | 			    : tee_or_impl_1<false, C, Fs..., L> {};
199 | 			template <typename C, typename... Fs>
200 | 			struct tee_impl<uint_<1>, identity_, or_<identity_, C>, Fs...>
201 | 			    : tee_or_impl_1<false, C, Fs..., identity_> {};
202 | 			template <typename L, typename C, typename... Fs>
203 | 			struct tee_impl<uint_<2>, L, or_<identity_, C>, Fs...>
204 | 			    : tee_or_impl_2<false, C, Fs..., L> {};
205 | 
206 | 			template <unsigned N, typename F0, typename F1, typename... Fs>
207 | 			struct dispatch<N, tee_<F0, F1, Fs...>>
208 | 			    : dispatch<find_dispatch(sizeof...(Fs) + 2),
209 | 			               rotate_<uint_<sizeof...(Fs)>, push_front_<uint_<N>, lift_<tee_impl>>>>::
210 | 			              template f<F0, F1, Fs...> {};
211 | 
212 | 		} // namespace detail
213 | 	} // namespace tmp
214 | } // namespace boost
215 | 
216 | #endif
217 | 


--------------------------------------------------------------------------------
/include/boost/tmp/sequence/reverse.hpp:
--------------------------------------------------------------------------------
  1 | #ifndef BOOST_TMP_REVERSE_HPP_INCLUDED
  2 | #define BOOST_TMP_REVERSE_HPP_INCLUDED
  3 | 
  4 | //  Copyright 2018 Odin Holmes.
  5 | //
  6 | //  Distributed under the Boost Software License, Version 1.0.
  7 | //
  8 | //  See accompanying file LICENSE_1_0.txt or copy at
  9 | //  http://www.boost.org/LICENSE_1_0.txt
 10 | 
 11 | #include "../vocabulary.hpp"
 12 | 
 13 | namespace boost {
 14 | 	namespace tmp {
 15 | 		template <typename C = listify_>
 16 | 		struct reverse_ {};
 17 | 
 18 | 		namespace detail {
 19 | 			template <typename C, typename... Ts>
 20 | 			struct reverse_impl {
 21 | 				template <typename... Us>
 22 | 				using f = typename dispatch<find_dispatch(sizeof...(Ts) + sizeof...(Us)),
 23 | 				                            C>::template f<Ts..., Us...>;
 24 | 			};
 25 | 
 26 | 			template <typename C>
 27 | 			struct dispatch<0, reverse_<C>> {
 28 | 				template <typename...>
 29 | 				using f = typename dispatch<0, C>::template f<>;
 30 | 			};
 31 | 
 32 | 			template <typename C>
 33 | 			struct dispatch<1, reverse_<C>> {
 34 | 				template <typename T>
 35 | 				using f = typename dispatch<1, C>::template f<T>;
 36 | 			};
 37 | 
 38 | 			template <typename C>
 39 | 			struct dispatch<2, reverse_<C>> {
 40 | 				template <typename T0, typename T1>
 41 | 				using f = typename dispatch<2, C>::template f<T1, T0>;
 42 | 			};
 43 | 
 44 | 			template <typename C>
 45 | 			struct dispatch<3, reverse_<C>> {
 46 | 				template <typename T0, typename T1, typename T2>
 47 | 				using f = typename dispatch<3, C>::template f<T2, T1, T0>;
 48 | 			};
 49 | 			template <typename C>
 50 | 			struct dispatch<4, reverse_<C>> {
 51 | 				template <typename T0, typename T1, typename T2, typename T3>
 52 | 				using f = typename dispatch<4, C>::template f<T3, T2, T1, T0>;
 53 | 			};
 54 | 			template <typename C>
 55 | 			struct dispatch<5, reverse_<C>> {
 56 | 				template <typename T0, typename T1, typename T2, typename T3, typename T4>
 57 | 				using f = typename dispatch<5, C>::template f<T4, T3, T2, T1, T0>;
 58 | 			};
 59 | 			template <typename C>
 60 | 			struct dispatch<6, reverse_<C>> {
 61 | 				template <typename T0, typename T1, typename T2, typename T3, typename T4,
 62 | 				          typename T5>
 63 | 				using f = typename dispatch<6, C>::template f<T5, T4, T3, T2, T1, T0>;
 64 | 			};
 65 | 			template <typename C>
 66 | 			struct dispatch<7, reverse_<C>> {
 67 | 				template <typename T0, typename T1, typename T2, typename T3, typename T4,
 68 | 				          typename T5, typename T6>
 69 | 				using f = typename dispatch<7, C>::template f<T6, T5, T4, T3, T2, T1, T0>;
 70 | 			};
 71 | 			template <typename C>
 72 | 			struct dispatch<8, reverse_<C>> {
 73 | 				template <typename T0, typename T1, typename T2, typename T3, typename T4,
 74 | 				          typename T5, typename T6, typename T7>
 75 | 				using f = typename dispatch<8, C>::template f<T7, T6, T5, T4, T3, T2, T1, T0>;
 76 | 			};
 77 | 			template <typename C>
 78 | 			struct dispatch<9, reverse_<C>> {
 79 | 				template <typename T0, typename T1, typename T2, typename T3, typename T4,
 80 | 				          typename T5, typename T6, typename T7, typename... Ts>
 81 | 				using f = typename dispatch<find_dispatch(sizeof...(Ts) + 1),
 82 | 				                            reverse_<lift_<reverse_impl>>>::template f<Ts..., C>::
 83 | 				        template f<T7, T6, T5, T4, T3, T2, T1, T0>;
 84 | 			};
 85 | 			template <typename C>
 86 | 			struct dispatch<16, reverse_<C>> {
 87 | 				template <typename T0, typename T1, typename T2, typename T3, typename T4,
 88 | 				          typename T5, typename T6, typename T7, typename T8, typename T9,
 89 | 				          typename T10, typename T11, typename T12, typename T13, typename T14,
 90 | 				          typename T15>
 91 | 				using f = typename dispatch<16, C>::template f<T15, T14, T13, T12, T11, T10, T9, T8,
 92 | 				                                               T7, T6, T5, T4, T3, T2, T1, T0>;
 93 | 			};
 94 | 			template <typename C>
 95 | 			struct dispatch<17, reverse_<C>> {
 96 | 				template <typename T0, typename T1, typename T2, typename T3, typename T4,
 97 | 				          typename T5, typename T6, typename T7, typename T8, typename T9,
 98 | 				          typename T10, typename T11, typename T12, typename T13, typename T14,
 99 | 				          typename T15, typename... Ts>
100 | 				using f = typename dispatch<find_dispatch(sizeof...(Ts) + 1),
101 | 				                            reverse_<lift_<reverse_impl>>>::template f<Ts..., C>::
102 | 				        template f<T15, T14, T13, T12, T11, T10, T9, T8, T7, T6, T5, T4, T3, T2, T1,
103 | 				                   T0>;
104 | 			};
105 | 			template <typename C>
106 | 			struct dispatch<32, reverse_<C>> {
107 | 				template <typename T0, typename T1, typename T2, typename T3, typename T4,
108 | 				          typename T5, typename T6, typename T7, typename T8, typename T9,
109 | 				          typename T10, typename T11, typename T12, typename T13, typename T14,
110 | 				          typename T15, typename T16, typename T17, typename T18, typename T19,
111 | 				          typename T20, typename T21, typename T22, typename T23, typename T24,
112 | 				          typename T25, typename T26, typename T27, typename T28, typename T29,
113 | 				          typename T30, typename T31>
114 | 				using f = typename dispatch<32, C>::template f<
115 | 				        T31, T30, T29, T28, T27, T26, T25, T24, T23, T22, T21, T20, T19, T18, T17,
116 | 				        T16, T15, T14, T13, T12, T11, T10, T9, T8, T7, T6, T5, T4, T3, T2, T1, T0>;
117 | 			};
118 | 			template <typename C>
119 | 			struct dispatch<33, reverse_<C>> {
120 | 				template <typename T0, typename T1, typename T2, typename T3, typename T4,
121 | 				          typename T5, typename T6, typename T7, typename T8, typename T9,
122 | 				          typename T10, typename T11, typename T12, typename T13, typename T14,
123 | 				          typename T15, typename T16, typename T17, typename T18, typename T19,
124 | 				          typename T20, typename T21, typename T22, typename T23, typename T24,
125 | 				          typename T25, typename T26, typename T27, typename T28, typename T29,
126 | 				          typename T30, typename T31, typename... Ts>
127 | 				using f = typename dispatch<find_dispatch(sizeof...(Ts) + 1),
128 | 				                            reverse_<lift_<reverse_impl>>>::template f<Ts..., C>::
129 | 				        template f<T31, T30, T29, T28, T27, T26, T25, T24, T23, T22, T21, T20, T19,
130 | 				                   T18, T17, T16, T15, T14, T13, T12, T11, T10, T9, T8, T7, T6, T5,
131 | 				                   T4, T3, T2, T1, T0>;
132 | 			};
133 | 			template <typename C>
134 | 			struct dispatch<64, reverse_<C>> {
135 | 				template <typename T0, typename T1, typename T2, typename T3, typename T4,
136 | 				          typename T5, typename T6, typename T7, typename T8, typename T9,
137 | 				          typename T10, typename T11, typename T12, typename T13, typename T14,
138 | 				          typename T15, typename T16, typename T17, typename T18, typename T19,
139 | 				          typename T20, typename T21, typename T22, typename T23, typename T24,
140 | 				          typename T25, typename T26, typename T27, typename T28, typename T29,
141 | 				          typename T30, typename T31, typename T32, typename T33, typename T34,
142 | 				          typename T35, typename T36, typename T37, typename T38, typename T39,
143 | 				          typename T40, typename T41, typename T42, typename T43, typename T44,
144 | 				          typename T45, typename T46, typename T47, typename T48, typename T49,
145 | 				          typename T50, typename T51, typename T52, typename T53, typename T54,
146 | 				          typename T55, typename T56, typename T57, typename T58, typename T59,
147 | 				          typename T60, typename T61, typename T62, typename T63>
148 | 				using f = typename dispatch<16, C>::template f<
149 | 				        T63, T62, T61, T60, T59, T58, T57, T56, T55, T54, T53, T52, T51, T50, T49,
150 | 				        T48, T47, T46, T45, T44, T43, T42, T41, T40, T39, T38, T37, T36, T35, T34,
151 | 				        T33, T32, T31, T30, T29, T28, T27, T26, T25, T24, T23, T22, T21, T20, T19,
152 | 				        T18, T17, T16, T15, T14, T13, T12, T11, T10, T9, T8, T7, T6, T5, T4, T3, T2,
153 | 				        T1, T0>;
154 | 			};
155 | 			template <typename C>
156 | 			struct dispatch<65, reverse_<C>> {
157 | 				template <typename T0, typename T1, typename T2, typename T3, typename T4,
158 | 				          typename T5, typename T6, typename T7, typename T8, typename T9,
159 | 				          typename T10, typename T11, typename T12, typename T13, typename T14,
160 | 				          typename T15, typename T16, typename T17, typename T18, typename T19,
161 | 				          typename T20, typename T21, typename T22, typename T23, typename T24,
162 | 				          typename T25, typename T26, typename T27, typename T28, typename T29,
163 | 				          typename T30, typename T31, typename T32, typename T33, typename T34,
164 | 				          typename T35, typename T36, typename T37, typename T38, typename T39,
165 | 				          typename T40, typename T41, typename T42, typename T43, typename T44,
166 | 				          typename T45, typename T46, typename T47, typename T48, typename T49,
167 | 				          typename T50, typename T51, typename T52, typename T53, typename T54,
168 | 				          typename T55, typename T56, typename T57, typename T58, typename T59,
169 | 				          typename T60, typename T61, typename T62, typename T63, typename... Ts>
170 | 				using f = typename dispatch<find_dispatch(sizeof...(Ts) + 1),
171 | 				                            reverse_<lift_<reverse_impl>>>::template f<Ts..., C>::
172 | 				        template f<T63, T62, T61, T60, T59, T58, T57, T56, T55, T54, T53, T52, T51,
173 | 				                   T50, T49, T48, T47, T46, T45, T44, T43, T42, T41, T40, T39, T38,
174 | 				                   T37, T36, T35, T34, T33, T32, T31, T30, T29, T28, T27, T26, T25,
175 | 				                   T24, T23, T22, T21, T20, T19, T18, T17, T16, T15, T14, T13, T12,
176 | 				                   T11, T10, T9, T8, T7, T6, T5, T4, T3, T2, T1, T0>;
177 | 			};
178 | 			template <unsigned N, typename C>
179 | 			struct dispatch<N, reverse_<C>> : dispatch<65, reverse_<C>> {};
180 | 		} // namespace detail
181 | 	} // namespace tmp
182 | } // namespace boost
183 | 
184 | #endif


--------------------------------------------------------------------------------
/include/boost/tmp/algorithm/fold_left.hpp:
--------------------------------------------------------------------------------
  1 | #ifndef BOOST_TMP_FOLD_LEFT_HPP_INCLUDED
  2 | #define BOOST_TMP_FOLD_LEFT_HPP_INCLUDED
  3 | 
  4 | //  Copyright 2018 Odin Holmes.
  5 | //
  6 | //  Distributed under the Boost Software License, Version 1.0.
  7 | //
  8 | //  See accompanying file LICENSE_1_0.txt or copy at
  9 | //  http://www.boost.org/LICENSE_1_0.txt
 10 | 
 11 | #include "../call.hpp"
 12 | #include "../detail/dispatch.hpp"
 13 | #include "../vocabulary.hpp"
 14 | 
 15 | namespace boost {
 16 | 	namespace tmp {
 17 | 		/// \brief folds left over a list using a binary predicate /
 18 | 		/// fold left considers the first element in the input pack the initial state, use
 19 | 		/// `push_front<>` to add initial state if needed
 20 | 		template <typename F = listify_, typename C = identity_>
 21 | 		struct fold_left_ {};
 22 | 		namespace detail {
 23 | 			template <template <typename...> class F, template <typename...> class C>
 24 | 			struct dispatch<0, fold_left_<lift_<F>, lift_<C>>> {
 25 | 				template <typename...>
 26 | 				using f = nothing_;
 27 | 			};
 28 | 			template <template <typename...> class F, template <typename...> class C>
 29 | 			struct dispatch<1, fold_left_<lift_<F>, lift_<C>>> {
 30 | 				template <typename T>
 31 | 				using f = C<T>;
 32 | 			};
 33 | 			template <template <typename...> class F, template <typename...> class C>
 34 | 			struct dispatch<2, fold_left_<lift_<F>, lift_<C>>> {
 35 | 				template <typename In, typename T0>
 36 | 				using f = C<F<In, T0>>;
 37 | 			};
 38 | 			template <template <typename...> class F, template <typename...> class C>
 39 | 			struct dispatch<3, fold_left_<lift_<F>, lift_<C>>> {
 40 | 				template <typename In, typename T0, typename T1>
 41 | 				using f = C<F<F<In, T0>, T1>>;
 42 | 			};
 43 | 			template <template <typename...> class F, template <typename...> class C>
 44 | 			struct dispatch<4, fold_left_<lift_<F>, lift_<C>>> {
 45 | 				template <typename In, typename T0, typename T1, typename T2>
 46 | 				using f = C<F<F<F<In, T0>, T1>, T2>>;
 47 | 			};
 48 | 			template <template <typename...> class F, template <typename...> class C>
 49 | 			struct dispatch<5, fold_left_<lift_<F>, lift_<C>>> {
 50 | 				template <typename In, typename T0, typename T1, typename T2, typename T3>
 51 | 				using f = C<F<F<F<F<In, T0>, T1>, T2>, T3>>;
 52 | 			};
 53 | 			template <template <typename...> class F, template <typename...> class C>
 54 | 			struct dispatch<6, fold_left_<lift_<F>, lift_<C>>> {
 55 | 				template <typename In, typename T0, typename T1, typename T2, typename T3,
 56 | 				          typename T4>
 57 | 				using f = C<F<F<F<F<F<In, T0>, T1>, T2>, T3>, T4>>;
 58 | 			};
 59 | 			template <template <typename...> class F, template <typename...> class C>
 60 | 			struct dispatch<7, fold_left_<lift_<F>, lift_<C>>> {
 61 | 				template <typename In, typename T0, typename T1, typename T2, typename T3,
 62 | 				          typename T4, typename T5>
 63 | 				using f = C<F<F<F<F<F<F<In, T0>, T1>, T2>, T3>, T4>, T5>>;
 64 | 			};
 65 | 			template <template <typename...> class F, template <typename...> class C>
 66 | 			struct dispatch<8, fold_left_<lift_<F>, lift_<C>>> {
 67 | 				template <typename In, typename T0, typename T1, typename T2, typename T3,
 68 | 				          typename T4, typename T5, typename T6>
 69 | 				using f = C<F<F<F<F<F<F<F<In, T0>, T1>, T2>, T3>, T4>, T5>, T6>>;
 70 | 			};
 71 | 			template <template <typename...> class F, template <typename...> class C>
 72 | 			struct dispatch<9, fold_left_<lift_<F>, lift_<C>>> {
 73 | 				template <typename In, typename T0, typename T1, typename T2, typename T3,
 74 | 				          typename T4, typename T5, typename T6, typename... Ts>
 75 | 				using f = typename dispatch<find_dispatch(sizeof...(Ts) + 1),
 76 | 				                            fold_left_<lift_<F>, lift_<C>>>::
 77 | 				        template f<F<F<F<F<F<F<F<In, T0>, T1>, T2>, T3>, T4>, T5>, T6>, Ts...>;
 78 | 			};
 79 | 			template <template <typename...> class F, template <typename...> class C>
 80 | 			struct dispatch<16, fold_left_<lift_<F>, lift_<C>>> {
 81 | 				template <typename In, typename T0, typename T1, typename T2, typename T3,
 82 | 				          typename T4, typename T5, typename T6, typename T7, typename T8,
 83 | 				          typename T9, typename T10, typename T11, typename T12, typename T13,
 84 | 				          typename T14, typename... Ts>
 85 | 				using f = typename dispatch<find_dispatch(sizeof...(Ts) + 1),
 86 | 				                            fold_left_<lift_<F>, lift_<C>>>::
 87 | 				        template f<
 88 | 				                F<F<F<F<F<F<F<F<F<F<F<F<F<F<F<In, T0>, T1>, T2>, T3>, T4>, T5>, T6>,
 89 | 				                                T7>,
 90 | 				                              T8>,
 91 | 				                            T9>,
 92 | 				                          T10>,
 93 | 				                        T11>,
 94 | 				                      T12>,
 95 | 				                    T13>,
 96 | 				                  T14>,
 97 | 				                Ts...>;
 98 | 			};
 99 | 			template <template <typename...> class F, template <typename...> class C>
100 | 			struct dispatch<17, fold_left_<lift_<F>, lift_<C>>>
101 | 			    : dispatch<16, fold_left_<lift_<F>, lift_<C>>> {};
102 | 			template <template <typename...> class F, template <typename...> class C>
103 | 			struct dispatch<32, fold_left_<lift_<F>, lift_<C>>> {
104 | 				template <typename In, typename T0, typename T1, typename T2, typename T3,
105 | 				          typename T4, typename T5, typename T6, typename T7, typename T8,
106 | 				          typename T9, typename T10, typename T11, typename T12, typename T13,
107 | 				          typename T14, typename T15, typename T16, typename T17, typename T18,
108 | 				          typename T19, typename T20, typename T21, typename T22, typename T23,
109 | 				          typename T24, typename T25, typename T26, typename T27, typename T28,
110 | 				          typename T29, typename T30, typename... Ts>
111 | 				using f = typename dispatch<find_dispatch(sizeof...(Ts) + 1),
112 | 				                            fold_left_<lift_<F>, lift_<C>>>::
113 | 				        template f<
114 | 				                F<F<F<F<F<F<F<F<F<F<F<F<F<F<F<F<F<F<F<F<F<F<F<F<F<F<F<F<F<F<F<In, T0>,
115 | 				                                                                            T1>,
116 | 				                                                                          T2>,
117 | 				                                                                        T3>,
118 | 				                                                                      T4>,
119 | 				                                                                    T5>,
120 | 				                                                                  T6>,
121 | 				                                                                T7>,
122 | 				                                                              T8>,
123 | 				                                                            T9>,
124 | 				                                                          T10>,
125 | 				                                                        T11>,
126 | 				                                                      T12>,
127 | 				                                                    T13>,
128 | 				                                                  T14>,
129 | 				                                                T15>,
130 | 				                                              T16>,
131 | 				                                            T17>,
132 | 				                                          T18>,
133 | 				                                        T19>,
134 | 				                                      T20>,
135 | 				                                    T21>,
136 | 				                                  T22>,
137 | 				                                T23>,
138 | 				                              T24>,
139 | 				                            T25>,
140 | 				                          T26>,
141 | 				                        T27>,
142 | 				                      T28>,
143 | 				                    T29>,
144 | 				                  T30>,
145 | 				                Ts...>;
146 | 			};
147 | 			template <template <typename...> class F, template <typename...> class C>
148 | 			struct dispatch<33, fold_left_<lift_<F>, lift_<C>>>
149 | 			    : dispatch<32, fold_left_<lift_<F>, lift_<C>>> {};
150 | 			template <template <typename...> class F, template <typename...> class C>
151 | 			struct dispatch<64, fold_left_<lift_<F>, lift_<C>>> {
152 | 				template <typename In, typename T0, typename T1,
153 | 						typename T2, typename T3, typename T4, typename T5, typename T6,
154 | 						typename T7, typename T8, typename T9, typename T10, typename T11,
155 | 						typename T12, typename T13, typename T14, typename T15, typename T16,
156 | 						typename T17, typename T18, typename T19, typename T20, typename T21,
157 | 						typename T22, typename T23, typename T24, typename T25, typename T26,
158 | 						typename T27, typename T28, typename T29, typename T30, typename T31,
159 | 						typename T32, typename T33, typename T34, typename T35, typename T36,
160 | 						typename T37, typename T38, typename T39, typename T40, typename T41,
161 | 						typename T42, typename T43, typename T44, typename T45, typename T46,
162 | 						typename T47, typename T48, typename T49, typename T50, typename T51,
163 | 						typename T52, typename T53, typename T54, typename T55, typename T56,
164 | 						typename T57, typename T58, typename T59, typename T60, typename T61,
165 | 						typename T62, typename T63, typename... Ts>
166 | 				using f = typename dispatch<find_dispatch(sizeof...(Ts) + 1),
167 | 						fold_left_<lift_<F>, lift_<C>>>::
168 | 				template f<F<F<F<F<F<F<F<F<F<F<F<F<F<F<F<F<F<F<F<F<F<F<F<F<F<F<F<F<F<F<F<F<F<F<F<F<F<F<F<F<F<F<F<F<F<F<F<F<F<F<F<F<F<F<F<F<F<F<F<F<F<F<F<F<In, T0>,
169 | 						T1>,
170 | 						T2>,
171 | 						T3>,
172 | 						T4>,
173 | 						T5>,
174 | 						T6>,
175 | 						T7>,
176 | 						T8>,
177 | 						T9>,
178 | 						T10>,
179 | 						T11>,
180 | 						T12>,
181 | 						T13>,
182 | 						T14>,
183 | 						T15>,
184 | 						T16>,
185 | 						T17>,
186 | 						T18>,
187 | 						T19>,
188 | 						T20>,
189 | 						T21>,
190 | 						T22>,
191 | 						T23>,
192 | 						T24>,
193 | 						T25>,
194 | 						T26>,
195 | 						T27>,
196 | 						T28>,
197 | 						T29>,
198 | 						T30>,
199 | 						T31>,
200 | 						T32>,
201 | 						T33>,
202 | 						T34>,
203 | 						T35>,
204 | 						T36>,
205 | 						T37>,
206 | 						T38>,
207 | 						T39>,
208 | 						T40>,
209 | 						T41>,
210 | 						T42>,
211 | 						T43>,
212 | 						T44>,
213 | 						T45>,
214 | 						T46>,
215 | 						T47>,
216 | 						T48>,
217 | 						T49>,
218 | 						T50>,
219 | 						T51>,
220 | 						T52>,
221 | 						T53>,
222 | 						T54>,
223 | 						T55>,
224 | 						T56>,
225 | 						T57>,
226 | 						T58>,
227 | 						T59>,
228 | 						T60>,
229 | 						T61>,
230 | 						T62>,
231 | 						T63>,
232 | 						Ts...>;
233 | 			};
234 | 			template <unsigned N, template <typename...> class F, template <typename...> class C>
235 | 			struct dispatch<N, fold_left_<lift_<F>, lift_<C>>>
236 | 			    : dispatch<64, fold_left_<lift_<F>, lift_<C>>> {};
237 | 
238 | 			template <unsigned N, typename F, typename C>
239 | 			struct dispatch<N, fold_left_<F, C>>
240 | 			    : dispatch<N, fold_left_<lift_<dispatch<2, F>::template f>,
241 | 			                             lift_<dispatch<1, C>::template f>>> {};
242 | 			template <unsigned N, template <typename...> class F, typename C>
243 | 			struct dispatch<N, fold_left_<lift_<F>, C>>
244 | 			    : dispatch<N, fold_left_<lift_<F>, lift_<dispatch<1, C>::template f>>> {};
245 | 			template <unsigned N, typename F, template <typename...> class C>
246 | 			struct dispatch<N, fold_left_<F, lift_<C>>>
247 | 			    : dispatch<N, fold_left_<lift_<dispatch<2, F>::template f>, lift_<C>>> {};
248 | 
249 | 		} // namespace detail
250 | 	} // namespace tmp
251 | } // namespace boost
252 | 
253 | #endif


--------------------------------------------------------------------------------
/test/sort_test.hpp:
--------------------------------------------------------------------------------
  1 | #include "test_util.hpp"
  2 | #include "../include/boost/tmp/algorithm/sort.hpp"
  3 | namespace sort_test {
  4 | 	template <typename T, typename U>
  5 | 	using less = bool_<(T::value < U::value)>;
  6 | 
  7 | 	template <typename T, typename U>
  8 | 	using push_ = typename T::template push<U, less>;
  9 | 	int run() {
 10 | 		list_<uint_<0>, uint_<1>, uint_<2>>{} =
 11 | 		        call_<sort_<lift_<less>>, uint_<1>, uint_<0>, uint_<2>>{};
 12 | 		call_<make_sequence_<>, uint_<100>>{} =
 13 | 		        call_<sort_<lift_<less>>, uint_<0>, uint_<27>, uint_<87>, uint_<3>, uint_<56>,
 14 | 		              uint_<76>, uint_<94>, uint_<17>, uint_<74>, uint_<55>, uint_<96>, uint_<54>,
 15 | 		              uint_<93>, uint_<79>, uint_<14>, uint_<8>, uint_<31>, uint_<23>, uint_<25>,
 16 | 		              uint_<34>, uint_<9>, uint_<44>, uint_<63>, uint_<4>, uint_<72>, uint_<46>,
 17 | 		              uint_<49>, uint_<7>, uint_<83>, uint_<77>, uint_<61>, uint_<81>, uint_<91>,
 18 | 		              uint_<69>, uint_<52>, uint_<28>, uint_<19>, uint_<57>, uint_<64>, uint_<75>,
 19 | 		              uint_<2>, uint_<62>, uint_<43>, uint_<42>, uint_<5>, uint_<16>, uint_<18>,
 20 | 		              uint_<41>, uint_<39>, uint_<6>, uint_<92>, uint_<60>, uint_<1>, uint_<35>,
 21 | 		              uint_<29>, uint_<51>, uint_<12>, uint_<36>, uint_<24>, uint_<53>, uint_<11>,
 22 | 		              uint_<32>, uint_<67>, uint_<58>, uint_<80>, uint_<86>, uint_<33>, uint_<85>,
 23 | 		              uint_<15>, uint_<90>, uint_<20>, uint_<30>, uint_<50>, uint_<98>, uint_<99>,
 24 | 		              uint_<70>, uint_<21>, uint_<95>, uint_<73>, uint_<78>, uint_<26>, uint_<38>,
 25 | 		              uint_<82>, uint_<47>, uint_<40>, uint_<66>, uint_<59>, uint_<13>, uint_<89>,
 26 | 		              uint_<71>, uint_<88>, uint_<37>, uint_<22>, uint_<84>, uint_<10>, uint_<97>,
 27 | 		              uint_<68>, uint_<65>, uint_<48>, uint_<45>>{};
 28 | 
 29 | 		return 0;
 30 | 	}
 31 | } // namespace sort_test
 32 | /*
 33 |  *
 34 |  * typename dispatch<find_dispatch(sizeof...(Ts)),
 35 |                             drop_<uuint_<64>,make_binary_tree<
 36 |                                 F,
 37 |                                 lift_<tree::balance_tree64>,
 38 |                                 typename
 39 | dispatch<find_dispatch(sizeof...(Ts)),take_<uuint_<64>,make_binary_tree<F>>>::template f<Ts...>
 40 |                         >>>::template f<Ts...>
 41 | 
 42 | boost::detail::tree::node<
 43 |     boost::detail::tree::node<
 44 |         boost::detail::tree::left_node<
 45 |             boost::detail::tree::leaf_node<
 46 |                 boost::uint_<1>
 47 |             >,
 48 |             boost::uint_<2>
 49 |         >,
 50 |         boost::uint_<3>,
 51 |         boost::detail::tree::node<
 52 |             boost::detail::tree::node<
 53 |                 boost::detail::tree::node<
 54 |                     boost::detail::tree::right_node<
 55 |                         boost::uint_<4>,
 56 |                         boost::detail::tree::left_node<
 57 |                              boost::detail::tree::right_node<
 58 |                                  boost::uint_<5>,
 59 |                                      boost::detail::tree::leaf_node<boost::uint_<6> >
 60 |                                  >,
 61 |                                  boost::uint_<7>
 62 |                              >
 63 |                          >,
 64 |                          boost::uint_<8>,
 65 |                          boost::detail::tree::right_node<
 66 |                              boost::uint_<9>,
 67 |                              boost::detail::tree::node<
 68 |                                  boost::detail::tree::left_node<
 69 |                                      boost::detail::tree::leaf_node<boost::uint_<10> >,
 70 |                                      boost::uint_<11>
 71 |                                  >,
 72 |                              boost::uint_<12>,
 73 |                          boost::detail::tree::leaf_node<boost::uint_<13> >
 74 |                      >
 75 |                  >
 76 |              >,
 77 |              'Äboost::uint_<14>,
 78 | boost::detail::tree::left_node<boost::detail::tree::leaf_node<boost::uint_<15> >, boost::uint_<16> >
 79 | >, boost::uint_<17>,
 80 | boost::detail::tree::node<boost::detail::tree::node<boost::detail::tree::leaf_node<boost::uint_<18>
 81 | >, boost::uint_<19>, boost::detail::tree::right_node<boost::uint_<20>,
 82 | boost::detail::tree::right_node<boost::uint_<21>, boost::detail::tree::leaf_node<boost::uint_<22> >
 83 | > > >, boost::uint_<23>, boost::detail::tree::node<boost::detail::tree::leaf_node<boost::uint_<24>
 84 | >, boost::uint_<25>, boost::detail::tree::leaf_node<boost::uint_<26> > > > > >, boost::uint_<27>,
 85 | boost::detail::tree::node<boost::detail::tree::node<boost::detail::tree::left_node<boost::detail::tree::left_node<boost::detail::tree::node<boost::detail::tree::right_node<boost::uint_<28>,
 86 | boost::detail::tree::right_node<boost::uint_<29>, boost::detail::tree::leaf_node<boost::uint_<30> >
 87 | > >, boost::uint_<31>, boost::detail::tree::node<boost::detail::tree::right_node<boost::uint_<32>,
 88 | boost::detail::tree::leaf_node<boost::uint_<33> > >, boost::uint_<34>,
 89 | boost::detail::tree::node<boost::detail::tree::left_node<boost::detail::tree::left_node<boost::detail::tree::left_node<boost::detail::tree::node<boost::detail::tree::right_node<boost::uint_<35>,
 90 | boost::detail::tree::right_node<boost::uint_<36>,
 91 | boost::detail::tree::left_node<boost::detail::tree::leaf_node<boost::uint_<37> >, boost::uint_<38> >
 92 | > >, boost::uint_<39>, boost::detail::tree::leaf_node<boost::uint_<40> > >, boost::uint_<41> >,
 93 | boost::uint_<42> >, boost::uint_<43> >, boost::uint_<44>,
 94 | boost::detail::tree::node<boost::detail::tree::leaf_node<boost::uint_<45> >, boost::uint_<46>,
 95 | boost::detail::tree::node<boost::detail::tree::right_node<boost::uint_<47>,
 96 | boost::detail::tree::leaf_node<boost::uint_<48> > >, boost::uint_<49>,
 97 | boost::detail::tree::node<boost::detail::tree::left_node<boost::detail::tree::leaf_node<boost::uint_<50>
 98 | >, boost::uint_<51> >, boost::uint_<52>, boost::detail::tree::leaf_node<boost::uint_<53> > > > > > >
 99 | >, boost::uint_<54> >, boost::uint_<55> >, boost::uint_<56>,
100 | boost::detail::tree::node<boost::detail::tree::node<boost::detail::tree::node<boost::detail::tree::node<boost::detail::tree::right_node<boost::uint_<57>,
101 | boost::detail::tree::left_node<boost::detail::tree::right_node<boost::uint_<58>,
102 | boost::detail::tree::leaf_node<boost::uint_<59> > >, boost::uint_<60> > >, boost::uint_<61>,
103 | boost::detail::tree::leaf_node<boost::uint_<62> > >, boost::uint_<63>,
104 | boost::detail::tree::node<boost::detail::tree::node<boost::detail::tree::right_node<boost::uint_<64>,
105 | boost::detail::tree::node<boost::detail::tree::left_node<boost::detail::tree::leaf_node<boost::uint_<65>
106 | >, boost::uint_<66> >, boost::uint_<67>, boost::detail::tree::leaf_node<boost::uint_<68> > > >,
107 | boost::uint_<69>, boost::detail::tree::right_node<boost::uint_<70>,
108 | boost::detail::tree::leaf_node<boost::uint_<71> > > >, boost::uint_<72>,
109 | boost::detail::tree::leaf_node<boost::uint_<73> > > >, boost::uint_<74>,
110 | boost::detail::tree::leaf_node<boost::uint_<75> > >, boost::uint_<76>,
111 | boost::detail::tree::node<boost::detail::tree::right_node<boost::uint_<77>,
112 | boost::detail::tree::leaf_node<boost::uint_<78> > >, boost::uint_<79>,
113 | boost::detail::tree::node<boost::detail::tree::node<boost::detail::tree::leaf_node<boost::uint_<80>
114 | >, boost::uint_<81>, boost::detail::tree::leaf_node<boost::uint_<82> > >, boost::uint_<83>,
115 | boost::detail::tree::left_node<boost::detail::tree::left_node<boost::detail::tree::leaf_node<boost::uint_<84>
116 | >, boost::uint_<85> >, boost::uint_<86> > > > > >, boost::uint_<87>,
117 | boost::detail::tree::node<boost::detail::tree::left_node<boost::detail::tree::node<boost::detail::tree::left_node<boost::detail::tree::left_node<boost::detail::tree::leaf_node<boost::uint_<88>
118 | >, boost::uint_<89> >, boost::uint_<90> >, boost::uint_<91>,
119 | boost::detail::tree::leaf_node<boost::uint_<92> > >, boost::uint_<93> >, boost::uint_<94>,
120 | boost::detail::tree::node<boost::detail::tree::leaf_node<boost::uint_<95> >, boost::uint_<96>,
121 | boost::detail::tree::left_node<boost::detail::tree::node<boost::detail::tree::leaf_node<boost::uint_<97>
122 | >, boost::uint_<98>, boost::detail::tree::leaf_node<boost::uint_<99> > >, boost::uint_<100> > > > >
123 | >'} to non-scalar type 'boost::call_<boost::make_sequence_<>, boost::uuint_<100> >' {aka
124 | 'boost::list_<boost::uuint_<0>, boost::uuint_<1>, boost::uuint_<2>, boost::uuint_<3>,
125 | boost::uuint_<4>, boost::uuint_<5>, boost::uuint_<6>, boost::uuint_<7>, boost::uuint_<8>,
126 | boost::uuint_<9>, boost::uuint_<10>, boost::uuint_<11>, boost::uuint_<12>, boost::uuint_<13>,
127 | boost::uuint_<14>, boost::uuint_<15>, boost::uuint_<16>, boost::uuint_<17>, boost::uuint_<18>,
128 | boost::uuint_<19>, boost::uuint_<20>, boost::uuint_<21>, boost::uuint_<22>, boost::uuint_<23>,
129 | boost::uuint_<24>, boost::uuint_<25>, boost::uuint_<26>, boost::uuint_<27>, boost::uuint_<28>,
130 | boost::uuint_<29>, boost::uuint_<30>, boost::uuint_<31>, boost::uuint_<32>, boost::uuint_<33>,
131 | boost::uuint_<34>, boost::uuint_<35>, boost::uuint_<36>, boost::uuint_<37>, boost::uuint_<38>,
132 | boost::uuint_<39>, boost::uuint_<40>, boost::uuint_<41>, boost::uuint_<42>, boost::uuint_<43>,
133 | boost::uuint_<44>, boost::uuint_<45>, boost::uuint_<46>, boost::uuint_<47>, boost::uuint_<48>,
134 | boost::uuint_<49>, boost::uuint_<50>, boost::uuint_<51>, boost::uuint_<52>, boost::uuint_<53>,
135 | boost::uuint_<54>, boost::uuint_<55>, boost::uuint_<56>, boost::uuint_<57>, boost::uuint_<58>,
136 | boost::uuint_<59>, boost::uuint_<60>, boost::uuint_<61>, boost::uuint_<62>, boost::uuint_<63>,
137 | boost::uuint_<64>, boost::uuint_<65>, boost::uuint_<66>, boost::uuint_<67>, boost::uuint_<68>,
138 | boost::uuint_<69>, boost::uuint_<70>, boost::uuint_<71>, boost::uuint_<72>, boost::uuint_<73>,
139 | boost::uuint_<74>, boost::uuint_<75>, boost::uuint_<76>, boost::uuint_<77>, boost::uuint_<78>,
140 | boost::uuint_<79>, boost::uuint_<80>, boost::uuint_<81>, boost::uuint_<82>, boost::uuint_<83>,
141 | boost::uuint_<84>, boost::uuint_<85>, boost::uuint_<86>, boost::uuint_<87>, boost::uuint_<88>,
142 | boost::uuint_<89>, boost::uuint_<90>, boost::uuint_<91>, boost::uuint_<92>, boost::uuint_<93>,
143 | boost::uuint_<94>, boost::uuint_<95>, boost::uuint_<96>, boost::uuint_<97>, boost::uuint_<98>,
144 | boost::uuint_<99> >'} requested
145 |              _
146 |              _
147 | 
148 |    call_<make_sequence_<>,uuint_<100>> r1 = call_<detail::make_binary_tree<lift_<less>>,uint_<27>,
149 | uint_<87>, uint_<3>, uint_<56>, uint_<76>, uint_<94>, uint_<17>, uint_<74>, uint_<55>, uint_<96>,
150 | uint_<54>, uint_<93>, uint_<79>, uint_<14>, uint_<8>, uint_<31>, uint_<23>, uint_<25>, uint_<34>,
151 | uint_<9>, uint_<44>, uint_<63>, uint_<4>, uint_<72>, uint_<46>, uint_<49>, uint_<7>, uint_<100>,
152 | uint_<83>, uint_<77>, uint_<61>, uint_<81>, uint_<91>, uint_<69>, uint_<52>, uint_<28>, uint_<19>,
153 | uint_<57>, uint_<64>, uint_<75>, uint_<2>, uint_<62>, uint_<43>, uint_<42>, uint_<5>, uint_<16>,
154 | uint_<18>, uint_<41>, uint_<39>, uint_<6>, uint_<92>, uint_<60>, uint_<1>, uint_<35>, uint_<29>,
155 | uint_<51>, uint_<12>, uint_<36>, uint_<24>, uint_<53>, uint_<11>, uint_<32>, uint_<67>, uint_<58>,
156 | uint_<80>, uint_<86>, uint_<33>, uint_<85>, uint_<15>, uint_<90>, uint_<20>, uint_<30>, uint_<50>,
157 | uint_<98>, uint_<99>, uint_<70>, uint_<21>, uint_<95>, uint_<73>, uint_<78>, uint_<26>, uint_<38>,
158 | uint_<82>, uint_<47>, uint_<40>, uint_<66>, uint_<59>, uint_<13>, uint_<89>, uint_<71>, uint_<88>,
159 | uint_<37>, uint_<22>, uint_<84>, uint_<10>, uint_<97>, uint_<68>, uint_<65>, uint_<48>,
160 | uint_<45>>{};
161 | 
162 | 
163 | boost::list_<
164 |         boost::uint_<1>, boost::uint_<1>, boost::uint_<2>, boost::uint_<2>, boost::uint_<3>,
165 | boost::uint_<4>, boost::uint_<5>, boost::uint_<5>, boost::uint_<6>, boost::uint_<6>,
166 | boost::uint_<7>, boost::uint_<8>, boost::uint_<9>, boost::uint_<10>, boost::uint_<10>,
167 | boost::uint_<11>, boost::uint_<11>, boost::uint_<12>, boost::uint_<12>, boost::uint_<13>,
168 | boost::uint_<13>, boost::uint_<14>, boost::uint_<15>, boost::uint_<16>, boost::uint_<16>,
169 | boost::uint_<17>, boost::uint_<18>, boost::uint_<18>, boost::uint_<19>, boost::uint_<20>,
170 | boost::uint_<21>, boost::uint_<22>, boost::uint_<22>, boost::uint_<23>, boost::uint_<24>,
171 | boost::uint_<24>, boost::uint_<25>, boost::uint_<26>, boost::uint_<27>, boost::uint_<28>,
172 | boost::uint_<29>, boost::uint_<29>, boost::uint_<30>, boost::uint_<31>, boost::uint_<32>,
173 | boost::uint_<32>, boost::uint_<33>, boost::uint_<34>, boost::uint_<35>, boost::uint_<35>,
174 | boost::uint_<36>, boost::uint_<36>, boost::uint_<37>, boost::uint_<37>, boost::uint_<38>,
175 | boost::uint_<39>, boost::uint_<39>, boost::uint_<40>, boost::uint_<40>, boost::uint_<41>,
176 | boost::uint_<41>, boost::uint_<42>, boost::uint_<42>, boost::uint_<43>, boost::uint_<43>,
177 | boost::uint_<44>, boost::uint_<45>, boost::uint_<45>, boost::uint_<46>, boost::uint_<47>,
178 | boost::uint_<48>, boost::uint_<48>, boost::uint_<49>, boost::uint_<50>, boost::uint_<51>,
179 | boost::uint_<51>, boost::uint_<52>, boost::uint_<53>, boost::uint_<53>, boost::uint_<54>,
180 | boost::uint_<55>, boost::uint_<56>, boost::uint_<57>, boost::uint_<58>, boost::uint_<58>,
181 | boost::uint_<59>, boost::uint_<59>, boost::uint_<60>, boost::uint_<60>, boost::uint_<61>,
182 | boost::uint_<62>, boost::uint_<62>, boost::uint_<63>, boost::uint_<64>, boost::uint_<65>,
183 | boost::uint_<65>, boost::uint_<66>, boost::uint_<66>, boost::uint_<67>, boost::uint_<67>,
184 | boost::uint_<68>, boost::uint_<68>, boost::uint_<69>, boost::uint_<70>, boost::uint_<71>,
185 | boost::uint_<71>, boost::uint_<72>, boost::uint_<73>, boost::uint_<74>, boost::uint_<75>,
186 | boost::uint_<76>, boost::uint_<77>, boost::uint_<78>, boost::uint_<79>, boost::uint_<80>,
187 | boost::uint_<81>, boost::uint_<82>, boost::uint_<83>, boost::uint_<84>, boost::uint_<84>,
188 | boost::uint_<85>, boost::uint_<86>, boost::uint_<87>, boost::uint_<88>, boost::uint_<88>,
189 | boost::uint_<89>, boost::uint_<89>, boost::uint_<90>, boost::uint_<91>, boost::uint_<92>,
190 | boost::uint_<92>, boost::uint_<93>, boost::uint_<94>, boost::uint_<95>, boost::uint_<96>,
191 | boost::uint_<97>, boost::uint_<97>, boost::uint_<98>, boost::uint_<99>, boost::uint_<100> > >'
192 | 
193 | 
194 | ::tree::balance_tree64_impl<boost::list_<
195 |         boost::uint_<1>, boost::uint_<2>, boost::uint_<3>, boost::uint_<4>, boost::uint_<5>,
196 | boost::uint_<6>, boost::uint_<7>, boost::uint_<8>, boost::uint_<9>, boost::uint_<10>,
197 |         boost::uint_<11>, boost::uint_<12>, boost::uint_<13>, boost::uint_<14>, boost::uint_<15>,
198 | boost::uint_<16>, boost::uint_<17>, boost::uint_<18>, boost::uint_<19>, boost::uint_<20>,
199 |         boost::uint_<21>, boost::uint_<22>, boost::uint_<23>, boost::uint_<24>, boost::uint_<25>,
200 | boost::uint_<26>, boost::uint_<27>, boost::uint_<28>, boost::uint_<29>, boost::uint_<30>,
201 |         boost::uint_<31>, boost::uint_<32>, boost::uint_<33>, boost::uint_<34>, boost::uint_<35>,
202 | boost::uint_<36>, boost::uint_<37>, boost::uint_<38>, boost::uint_<39>, boost::uint_<40>,
203 |         boost::uint_<41>, boost::uint_<42>, boost::uint_<43>, boost::uint_<44>, boost::uint_<45>,
204 | boost::uint_<46>, boost::uint_<47>, boost::uint_<48>, boost::uint_<49>, boost::uint_<50>,
205 |         boost::uint_<51>, boost::uint_<52>, boost::uint_<53>, boost::uint_<54>, boost::uint_<55>,
206 | boost::uint_<56>, boost::uint_<57>, boost::uint_<58>, boost::uint_<59>, boost::uint_<60>,
207 |         boost::uint_<61>, boost::uint_<62>, boost::uint_<63>, boost::uint_<64>, boost::uint_<65>,
208 | boost::uint_<66>, boost::uint_<67>, boost::uint_<68>, boost::uint_<69>, boost::uint_<70>,
209 |         boost::uint_<71>, boost::uint_<72>, boost::uint_<73>, boost::uint_<74>, boost::uint_<75>,
210 | boost::uint_<76>, boost::uint_<77>, boost::uint_<78>, boost::uint_<79>, boost::uint_<80>,
211 |         boost::uint_<81>, boost::uint_<82>, boost::uint_<83>, boost::uint_<84>, boost::uint_<85>,
212 | boost::uint_<86>, boost::uint_<87>, boost::uint_<88>, boost::uint_<89>, boost::uint_<90>,
213 |         boost::uint_<91>, boost::uint_<92>, boost::uint_<93>, boost::uint_<94>, boost::uint_<95>,
214 | boost::uint_<96>, boost::uint_<97>, boost::uint_<98>, boost::uint_<99>, boost::uint_<100> > >'
215 | 
216 |  */


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 |  # boost.tmp (Tacit Meta Programming) 
  2 |  ## Warning! still work in progress
  3 | I decided to rewrite all of kvasir::mpl on a slightly different paradigm to extend compiler support further back and get some more speed out of low arity calls. Therefore most of this code has seen little or no testing beyond the skimpy unit test coverage so far. Bug reports welcome, do not use this in anything you don't want to see blow up spectacularly... yet. 
  4 | 
  5 |  ### What is boost.tmp?
  6 | A (not yet submitted to) boost general purpose Template Meta Programming (TMP) library which covers the domains of boost.MPL, boost.Fusion, boost.mp11 and boost.hana. 
  7 |  ### Why do we need another metaprogramming library in boost?
  8 | There are a few reasons:
  9 |  - a tacit DSL as the public interface allows for arbitrarily complex (almost) zero cost compositions of higher-order functions unlike current solutions
 10 |  - pattern matching, encapsulation of expertise and leverage of intrinsics often can yield even faster compile times than code handwritten by experts 
 11 |  - the interface is lazy/short-circuiting by default which removes the need for things like std::conjunction, std::disjunction etc. and makes SFINAE friendly code much easier to write, understand and teach
 12 |  - (still experimental) capture and monadic propagation of SFINAE failure allows for potentially more expressive, more intuitive and sometimes faster code in SFINAE contexts
 13 |  - (still experimental) heterogeneous l-, r-value reference support (as opposed to just values in hana)
 14 |  - (still experimental) heterogeneous (fusion) support in c++11
 15 |  - The tacit DSL nature of the interface enables much of the inner workings to be left undefined allowing us to swap out the back end for either legacy or future support. This should (grain of salt here) allow code written for a c++11 compiler to benefit from c++23 (I hope) work of SG7 (just implement the call_ alias such that it passes everything on to the newfangled constexpr monster) without the need to change user code.
 16 | 
 17 |  ## core concepts
 18 |  ### existing concepts
 19 | Allow me to do a short review of existing metaprogramming concepts. If you are familiar with these feel free to skip ahead to new concepts.
 20 | 
 21 |  #### template specialization
 22 | *This is starting at the very beginning, skip ahead to **lazy metafunctions** if you know what class templates are.* 
 23 | 
 24 | 
 25 | The workhorse of C++ metaprogramming is a language feature called class templates and template specialization. 
 26 | ```C++
 27 | template<typename T>
 28 | struct remove_const{              //generic template
 29 | 
 30 | };
 31 | ```
 32 | Above we have **defined** a class template named `remove_const` which takes one **type parameter** named `T`. This `T` parameter can be thought of a wildcard which can represent any type which the user *passed in*. We can *pass in* a parameter by naming it in a pair of trailing angle brackets:
 33 | ```C++
 34 | remove_const<int> a{};    //note that this does not actually remove const (yet)
 35 | ```
 36 | The above code defines a variable named `a` of type `remove_const<int>`. It should be noted that the type of a template instance consists of not only the template but all of its parameters. Therefore `remove_const<int>` and `remove_const<bool>` are two distinct types (or even `remove_const<const int>` for that matter). 
 37 | In order to make our `remove_const<T>` actually do what we intend we need to be able to do different things depending on whether the input is const or not. The right tool for the job, or the tool of choice for almost any kind of decision making or introspection in TMP for that matter, is called **partial specialization**.
 38 | ```C++
 39 | template<typename T>
 40 | struct remove_const{              	//definition
 41 | 
 42 | };
 43 | template<typename T>
 44 | struct remove_const<const T>{     //partial specialization
 45 | 
 46 | };
 47 | ```
 48 | ```C++
 49 | template<typename T>
 50 | struct remove_const{                  //definition
 51 | 
 52 | };
 53 | template<typename T>
 54 | struct remove_const<const T>{     //partial specialization 1
 55 | 
 56 | };
 57 | template<typename T>
 58 | struct remove_const<const volatile T>{     //partial specialization 2
 59 | 
 60 | };
 61 | remove_const<int> a; //does not match 1 or 2
 62 | remove_const<const int> b; //matches 1 and not 2
 63 | remove_const<volatile const int> c; //matches 1 and 2
 64 | ```
 65 | Above we can see that `a` only matches the generic definition, `b` matches specialization 1 and `c` matches both specializations. In the case of `c` specialization resolution is however not ambiguous because the pattern `const volatile T` can only match a smaller subset of all types compared to `const T` and is therefore considered **more specialized**. More specialized templates are considered a better match than less specialized templates. 
 66 |  
 67 |  #### lazy metafunctions
 68 | Lazy metafunctions are implemented using **class templates**. 
 69 | ```C++
 70 | template<typename T>
 71 | struct remove_const{              //generic template
 72 |     using type = T;
 73 | };
 74 | template<typename T>
 75 | struct remove_const<const T>{     //specialization
 76 |     using type = T;
 77 | };
 78 | ```
 79 | Above we are using class template specialization in order to implement a metafunction which removes const from its input parameter type. By adding a member alias named "type" (the name type is a convention, we could have named it anything) we can *return* a type from this **metafunction**. In this case, the "type" is an alias to the input type which, in the specialization case, has its const qualifier stripped. 
 80 | This metafunction is **lazy** in that the **instantiation** (think 'evaluation' or 'making the damn thing') only happens when we actually **call** the **metafunction**. We can **call** a **lazy** **metafunction** by referring to its nested "type" alias. 
 81 | ```C++
 82 | template<typename T>
 83 | typename remove_const<T>::type foo(T& a);  
 84 | ```
 85 | or more to the point
 86 | ```C++
 87 | typedef remove_const<T> thing;    //not instantiated yet
 88 | typename thing<int>::type i;                      //instantiated here
 89 | ```
 90 | Sadly above we must use the `typename` disambiguator in order to tell the compiler that the name "type" on the right-hand side of the :: is, in fact, a type and not a value, member function, template etc. This is one of the drawbacks of lazy metafunctions.
 91 | ```C++
 92 | template<typename T>
 93 | struct remove_const<int>{     //crazy specialization for int
 94 |     void type();  //now "type" is a function
 95 | };
 96 | template<typename T>
 97 | struct remove_const<bool>{     //crazy specialization for bool
 98 |     int type;  //now "type" is a value
 99 | };
100 | template<typename T>
101 | struct remove_const<char>{     //crazy specialization for char
102 |     template<int I>  //yes template parameters can also be values
103 |     struct type{
104 |         static int value = 1;
105 |     };  //now "type" is a class template
106 | };
107 | template<typename T>
108 | struct remove_const<long>{     //crazy specialization for long
109 |     template<int I>  //yes template parameters can also be values
110 |     int type();  //now "type" is a function template
111 | };
112 | ```
113 | As we can see above the name "type" could be any number of things and its not always clear which one the user is expecting. The default assumes that the user is expecting a nested name (think the thing on the right-hand side of a :: operator) of a **class template** to be a value. If we are expecting a function the compiler is also able to figure it out. If we are expecting a type rather than a value or function we need to prefix the expression with the `typename` **disambiguator**. If we are expecting a template for that matter we need to use the `template` **disambiguator**. 
114 | ```C++
115 | int a = add_const<bool>::template type<1>::value; //template disambiguator tells the
116 |                                                   //compoler that "type" is expected to be a template 
117 | 
118 | add_const<long> b{};                              //create instance of add_const<long>
119 | int c = b.template type<2>();                     //call member function template "type"
120 | ```
121 | 
122 |  #### eager metafunctions
123 | C++11 gave us a few new tools, not only variadic templates but also alias templates. 
124 | ```C++
125 | template<typename T>
126 | using add_const = const T;
127 | ```
128 | or 
129 | ```C++
130 | template<typename T>
131 | using remove_const_t = typename remove_const<T>::type;
132 | ```
133 | One advantage to alias templates is that the compiler knows the result of an alias call is a type so we no longer need to use the typename disambiguator. It also saves us typing out ::type all over the place. One major drawback, however, is that it does not allow us to be lazy, this is actually quite subtle at first, in the SFINAE section we will dive deeper into why we cannot deprecate lazy metafunctions from our public interface.  
134 | 
135 |  #### Substitution Failure Is Not An Error (SFINAE)
136 | SFINAE is a rule in C++ which applies to so-called **SFINAE contexts**, certain errors ([see list here](https://en.cppreference.com/w/cpp/language/sfinae)) in such contexts do not result in a compilation error (referred to as a **hard error**), rather, they result in the template specialization or function template in which the **SFINAE invocation** occurs to be removed from the set of specializations/overloads. 
137 | ```C++
138 | void f(...) {}   //bad match but will match anything
139 | template<typename T>
140 | typename T::type f(T){ return {}; } //better match but will be removed by SFINAE if T does not have a ::type
141 | ```
142 | This relates to eager vs. lazy metafunctions in a subtle way. Template instantiations do not short-circuit in the same way normal C++ expressions do. For example (thing1<T>::value || thing2<T>::value) will instantiate thing2<T> regardless of whether thing1<T>::value returned true. Metaprograms which actually short circuit in cases where our programming logic allows short-circuiting, not only have a potential efficiency gain they also save us from triggering SFINAE in an evaluation whos result is not needed because the logic should have short-circuited. 
143 | 
144 | Looking at an admittedly somewhat exotic example, let's say we want to to make sure that either our second parameter is an allocator or that both parameters have a common type (think `if(is_allocator(b) || has_common_type(a,b))`).
145 | ```C++ 
146 | template<typename T, typename U>
147 | std::enable_if<(is_allocator<U>::value || std::common_type_t<T,U>::value)> f(T,U);   //failed attempt, 
148 | 					//both sides are evaluated so common_type_t will 
149 | 					//SFINAE even if std::is_allocator<U>::value == true
150 | 					//also common_type_t yields a type and not a ::value
151 | 
152 | template<typename T, typename U>
153 | std::enable_if<
154 |     std::conditional<
155 |         is_allocator<U>::value, 
156 |         std::true_type, 
157 |         std::is_convertible< std::common_type<T,U> 
158 |     >::type::type::type::value> f(T,U);  //common pattern but its infinitely ugly
159 | 					//there are surely other 'hacks' but nothing 
160 | 					//that's not ugly and confusing
161 | ```
162 | As we can see writing short-circuiting capable metaprogramming logic is complex, confusing and more subtly relies entirely on lazy metafunctions. On a side note the above code snippet assumes that `is_allocator` exists, it is not part of the standard library. I will present a method of implementation for `is_allocator` as well as a new way to be short-circuiting later in new concepts.
163 | 
164 | #### higher order metafunctions
165 | Attempts at arbitrarily composable higher order metafunction are as old as metaprogramming itself, boost.MPL is the oldest popular metaprogramming library to support the concept but it seems that every template metaprogramming library since has come with its own flavor.
166 | The basic concept introduced in boost.MPL is based entirely on lazy matafunctions
167 | ```C++
168 | using result = transform<input_list,std::add_pointer<_1>>;
169 | ```
170 | in the above example, the algorithm transform is passed an input sequence of types as its first parameter and a higher order metafunction as its second parameter. But wait you say, `std::add_pointer<>` is just a lazy metafunction, that's entirely correct, however, we are exploiting the fact that it is not immediately evaluated and a placeholder in order to create a kind of DSL. The fact is that this `std::add_pointer<_1>` is never instantiated as such but is 'transpiled' into the boost.MPL flavor of composed higher-order metafunctions which replaces the placeholder with the respective input type from the input list and instantiates that. 
171 | Interestingly we can, almost, achieve arbitrarily complex compositions in this paradigm 
172 | ```C++
173 | using input_list = mpl::vector<int,bool,char>;
174 | using result = transform<input_list,
175 |     std::is_same<
176 |         std::remove_const<std::remove_reference<_1>>,
177 |         std::add_pointer<_1>>>;
178 | ```
179 | is roughly equivalent to
180 | ```C++
181 | using result = mpl::vector<
182 |     typename std::is_same<
183 |         typename std::remove_const<typename std::remove_reference<int>::type>::type,
184 |         typename std::add_pointer<int>::type>::type,
185 |     typename std::is_same<
186 |         typename std::remove_const<typename std::remove_reference<bool>::type>::type,
187 |         typename std::add_pointer<bool>::type>::type,
188 |     typename std::is_same<
189 |         typename std::remove_const<typename std::remove_reference<char>::type>::type,
190 |         typename std::add_pointer<char>::type>::type>;
191 | ```
192 | the 'transpiler' behind the scenes is actually quite powerfull and capable of flowing the branches of a tree-like composition. There are however some caveats: only lazy metafunctions are supported, 'wrappers' (thik putting things in a list) are supported through a SFINAE test which can cause subtle surprising behavior and things get really complicated as soon as one tries to use a higher order function in another higher order function. 
193 | 
194 | Many other libraries have emerged since boost.MPL which have experimented with different kinds of higher metafunctions and composition, including my (in my opinion) failed attempt in the brigand library. Before kvasir none of them could support arbitrary complexity without a considerable performance penalty and many of them require duplication of the public interface in one form or another (like the lazy namespace in brigand or quoted and non-quoted interface in boost.mp11). 
195 | 
196 |  ### new concepts
197 | #### metaclosures
198 | Above I have argued that lazy metafunctions are often clunky, require disambiguators, can be a performance hit and are hard to use in short-circuiting contexts. At the same time, eager metafunctions do not compose as ergonomically as higher-order metafunctions and cannot be lazy or short-circuiting. For these reasons I came up with a new metaprogramming concept: the **metaclosure**. 
199 | Metaclosures can be thought of as a function object with a set of 'fixed' or 'bound' arguments (think lambda capture) as well as a 'metafunction call interface' (think lambda function call operator). So far I have just been throwing made up words around so let's look at a concrete example:
200 | ```C++
201 | using result = call_<    //we use the call_ alias to call a metaclosure
202 |     is_<int>,        //is_ is a metaclosure which takes one fixed arguement
203 |                      //(int in this case)
204 |                      //and compares its to any arguement passed to it returning 
205 |                      //true_ if the types are the same and false_ otherwise.
206 |     int>;            //here we are passing an int to the metafunction call interface of 
207 |                      //is_<int> resulting in (in other words call_ resolves to an alias to) true_.
208 | 
209 | using result2 = call_<is_<int>, bool>; //result2 is an alias to false_
210 | ```
211 | 
212 | 
213 |                             
214 |     
215 | 
216 |  
217 |  ### Collaboration
218 | I have heard from many developers who must roll their own metaprogramming library at work because their lawyers are afraid to use something open source because the ownership structure is unclear (push to a repository with a certain license does not automatically mean that you are agreeing that your contribution can be used under that license, there is also the question of whether it was, in fact, the original author who pushed the code etc. etc.). Whether or not this concern is merited is another question (and one I cannot answer as I am not a lawyer), but I have decided to retain sole authorship of this library until I can get a Contributor License Agreement (CLA) worked out which is up to snuff. If you have knowledge in this field help would be much appreciated.
219 | I would be very happy for bug reports. I will offer this library under the boost license indefinitely (and may offer it under other licenses if needed), it may seem counter-intuitive but my motivation to restrict contributions (for now) is actually motivated by the intent to allow more people to use it.
220 | 
221 | 
222 | 


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