1#ifndef BOOST_MP11_ALGORITHM_HPP_INCLUDED
2#define BOOST_MP11_ALGORITHM_HPP_INCLUDED
3
4// Copyright 2015-2019 Peter Dimov
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 <boost/mp11/list.hpp>
12#include <boost/mp11/set.hpp>
13#include <boost/mp11/integral.hpp>
14#include <boost/mp11/utility.hpp>
15#include <boost/mp11/function.hpp>
16#include <boost/mp11/detail/mp_count.hpp>
17#include <boost/mp11/detail/mp_plus.hpp>
18#include <boost/mp11/detail/mp_map_find.hpp>
19#include <boost/mp11/detail/mp_with_index.hpp>
20#include <boost/mp11/detail/mp_fold.hpp>
21#include <boost/mp11/detail/mp_min_element.hpp>
22#include <boost/mp11/detail/mp_copy_if.hpp>
23#include <boost/mp11/detail/mp_remove_if.hpp>
24#include <boost/mp11/detail/config.hpp>
25#include <boost/mp11/integer_sequence.hpp>
26#include <type_traits>
27#include <utility>
28
29namespace boost
30{
31namespace mp11
32{
33
34// mp_transform<F, L...>
35namespace detail
36{
37
38template<template<class...> class F, class... L> struct mp_transform_impl
39{
40};
41
42template<template<class...> class F, template<class...> class L, class... T> struct mp_transform_impl<F, L<T...>>
43{
44#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, < 1920 )
45
46 template<class... U> struct f { using type = F<U...>; };
47
48 using type = L<typename f<T>::type...>;
49
50#else
51
52 using type = L<F<T>...>;
53
54#endif
55};
56
57template<template<class...> class F, template<class...> class L1, class... T1, template<class...> class L2, class... T2> struct mp_transform_impl<F, L1<T1...>, L2<T2...>>
58{
59#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, < 1920 )
60
61 template<class... U> struct f { using type = F<U...>; };
62
63 using type = L1<typename f<T1, T2>::type...>;
64
65#else
66
67 using type = L1<F<T1,T2>...>;
68
69#endif
70};
71
72template<template<class...> class F, template<class...> class L1, class... T1, template<class...> class L2, class... T2, template<class...> class L3, class... T3> struct mp_transform_impl<F, L1<T1...>, L2<T2...>, L3<T3...>>
73{
74#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, < 1920 )
75
76 template<class... U> struct f { using type = F<U...>; };
77
78 using type = L1<typename f<T1, T2, T3>::type...>;
79
80#else
81
82 using type = L1<F<T1,T2,T3>...>;
83
84#endif
85};
86
87#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, == 1900 ) || BOOST_MP11_WORKAROUND( BOOST_MP11_GCC, < 40800 )
88
89template<class... L> using mp_same_size_1 = mp_same<mp_size<L>...>;
90template<class... L> struct mp_same_size_2: mp_defer<mp_same_size_1, L...> {};
91
92#endif
93
94struct list_size_mismatch
95{
96};
97
98#if BOOST_MP11_WORKAROUND( BOOST_MP11_CUDA, >= 9000000 && BOOST_MP11_CUDA < 10000000 )
99
100template<template<class...> class F, class... L> struct mp_transform_cuda_workaround
101{
102 using type = mp_if<mp_same<mp_size<L>...>, detail::mp_transform_impl<F, L...>, detail::list_size_mismatch>;
103};
104
105#endif
106
107} // namespace detail
108
109#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, == 1900 ) || BOOST_MP11_WORKAROUND( BOOST_MP11_GCC, < 40800 )
110
111template<template<class...> class F, class... L> using mp_transform = typename mp_if<typename detail::mp_same_size_2<L...>::type, detail::mp_transform_impl<F, L...>, detail::list_size_mismatch>::type;
112
113#else
114
115#if BOOST_MP11_WORKAROUND( BOOST_MP11_CUDA, >= 9000000 && BOOST_MP11_CUDA < 10000000 )
116
117template<template<class...> class F, class... L> using mp_transform = typename detail::mp_transform_cuda_workaround< F, L...>::type::type;
118
119#else
120
121template<template<class...> class F, class... L> using mp_transform = typename mp_if<mp_same<mp_size<L>...>, detail::mp_transform_impl<F, L...>, detail::list_size_mismatch>::type;
122
123#endif
124
125#endif
126
127template<class Q, class... L> using mp_transform_q = mp_transform<Q::template fn, L...>;
128
129namespace detail
130{
131
132template<template<class...> class F, template<class...> class L1, class... T1, template<class...> class L2, class... T2, template<class...> class L3, class... T3, template<class...> class L4, class... T4, class... L> struct mp_transform_impl<F, L1<T1...>, L2<T2...>, L3<T3...>, L4<T4...>, L...>
133{
134 using A1 = L1<mp_list<T1, T2, T3, T4>...>;
135
136 template<class V, class T> using _f = mp_transform<mp_push_back, V, T>;
137
138 using A2 = mp_fold<mp_list<L...>, A1, _f>;
139
140 template<class T> using _g = mp_apply<F, T>;
141
142 using type = mp_transform<_g, A2>;
143};
144
145} // namespace detail
146
147// mp_transform_if<P, F, L...>
148namespace detail
149{
150
151template<template<class...> class P, template<class...> class F, class... L> struct mp_transform_if_impl
152{
153 // the stupid quote-unquote dance avoids "pack expansion used as argument for non-pack parameter of alias template"
154
155 using Qp = mp_quote<P>;
156 using Qf = mp_quote<F>;
157
158#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, < 1920 )
159
160 template<class... U> struct _f_ { using type = mp_eval_if_q<mp_not<mp_invoke_q<Qp, U...>>, mp_first<mp_list<U...>>, Qf, U...>; };
161 template<class... U> using _f = typename _f_<U...>::type;
162
163#else
164
165 template<class... U> using _f = mp_eval_if_q<mp_not<mp_invoke_q<Qp, U...>>, mp_first<mp_list<U...>>, Qf, U...>;
166
167#endif
168
169 using type = mp_transform<_f, L...>;
170};
171
172} // namespace detail
173
174template<template<class...> class P, template<class...> class F, class... L> using mp_transform_if = typename detail::mp_transform_if_impl<P, F, L...>::type;
175template<class Qp, class Qf, class... L> using mp_transform_if_q = typename detail::mp_transform_if_impl<Qp::template fn, Qf::template fn, L...>::type;
176
177// mp_filter<P, L...>
178namespace detail
179{
180
181template<template<class...> class P, class L1, class... L> struct mp_filter_impl
182{
183 using Qp = mp_quote<P>;
184
185 template<class T1, class... T> using _f = mp_if< mp_invoke_q<Qp, T1, T...>, mp_list<T1>, mp_list<> >;
186
187 using _t1 = mp_transform<_f, L1, L...>;
188 using _t2 = mp_apply<mp_append, _t1>;
189
190 using type = mp_assign<L1, _t2>;
191};
192
193} // namespace detail
194
195template<template<class...> class P, class... L> using mp_filter = typename detail::mp_filter_impl<P, L...>::type;
196template<class Q, class... L> using mp_filter_q = typename detail::mp_filter_impl<Q::template fn, L...>::type;
197
198// mp_fill<L, V>
199namespace detail
200{
201
202template<class L, class V> struct mp_fill_impl
203{
204// An error "no type named 'type'" here means that the L argument of mp_fill is not a list
205};
206
207template<template<class...> class L, class... T, class V> struct mp_fill_impl<L<T...>, V>
208{
209#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, <= 1900 )
210
211 template<class...> struct _f { using type = V; };
212 using type = L<typename _f<T>::type...>;
213
214#else
215
216 template<class...> using _f = V;
217 using type = L<_f<T>...>;
218
219#endif
220};
221
222#if defined(BOOST_MP11_HAS_TEMPLATE_AUTO)
223
224template<template<auto...> class L, auto... A, class V> struct mp_fill_impl<L<A...>, V>
225{
226 using type = L<((void)A, V::value)...>;
227};
228
229#endif
230
231} // namespace detail
232
233template<class L, class V> using mp_fill = typename detail::mp_fill_impl<L, V>::type;
234
235// mp_contains<L, V>
236template<class L, class V> using mp_contains = mp_to_bool<mp_count<L, V>>;
237
238// mp_repeat(_c)<L, N>
239namespace detail
240{
241
242template<class L, std::size_t N> struct mp_repeat_c_impl
243{
244 using _l1 = typename mp_repeat_c_impl<L, N/2>::type;
245 using _l2 = typename mp_repeat_c_impl<L, N%2>::type;
246
247 using type = mp_append<_l1, _l1, _l2>;
248};
249
250template<class L> struct mp_repeat_c_impl<L, 0>
251{
252 using type = mp_clear<L>;
253};
254
255template<class L> struct mp_repeat_c_impl<L, 1>
256{
257 using type = L;
258};
259
260} // namespace detail
261
262template<class L, std::size_t N> using mp_repeat_c = typename detail::mp_repeat_c_impl<L, N>::type;
263template<class L, class N> using mp_repeat = typename detail::mp_repeat_c_impl<L, std::size_t{ N::value }>::type;
264
265// mp_product<F, L...>
266namespace detail
267{
268
269template<template<class...> class F, class P, class... L> struct mp_product_impl_2
270{
271};
272
273template<template<class...> class F, class P> struct mp_product_impl_2<F, P>
274{
275 using type = mp_list<mp_rename<P, F>>;
276};
277
278template<template<class...> class F, class P, template<class...> class L1, class... T1, class... L> struct mp_product_impl_2<F, P, L1<T1...>, L...>
279{
280 using type = mp_append<typename mp_product_impl_2<F, mp_push_back<P, T1>, L...>::type...>;
281};
282
283template<template<class...> class F, class... L> struct mp_product_impl
284{
285};
286
287template<template<class...> class F> struct mp_product_impl<F>
288{
289 using type = mp_list< F<> >;
290};
291
292template<template<class...> class F, class L1, class... L> struct mp_product_impl<F, L1, L...>
293{
294 using type = mp_assign<L1, typename mp_product_impl_2<F, mp_list<>, L1, L...>::type>;
295};
296
297} // namespace detail
298
299template<template<class...> class F, class... L> using mp_product = typename detail::mp_product_impl<F, L...>::type;
300template<class Q, class... L> using mp_product_q = typename detail::mp_product_impl<Q::template fn, L...>::type;
301
302// mp_drop(_c)<L, N>
303namespace detail
304{
305
306template<class L, class L2, class En> struct mp_drop_impl;
307
308template<template<class...> class L, class... T, template<class...> class L2, class... U> struct mp_drop_impl<L<T...>, L2<U...>, mp_true>
309{
310 template<class... W> static mp_identity<L<W...>> f( U*..., mp_identity<W>*... );
311
312 using R = decltype( f( static_cast<mp_identity<T>*>(0) ... ) );
313
314 using type = typename R::type;
315};
316
317} // namespace detail
318
319template<class L, std::size_t N> using mp_drop_c = mp_assign<L, typename detail::mp_drop_impl<mp_rename<L, mp_list>, mp_repeat_c<mp_list<void>, N>, mp_bool<N <= mp_size<L>::value>>::type>;
320
321template<class L, class N> using mp_drop = mp_drop_c<L, std::size_t{ N::value }>;
322
323// mp_from_sequence<S, F>
324namespace detail
325{
326
327template<class S, class F> struct mp_from_sequence_impl;
328
329template<template<class T, T... I> class S, class U, U... J, class F> struct mp_from_sequence_impl<S<U, J...>, F>
330{
331 using type = mp_list_c<U, (F::value + J)...>;
332};
333
334} // namespace detail
335
336template<class S, class F = mp_int<0>> using mp_from_sequence = typename detail::mp_from_sequence_impl<S, F>::type;
337
338// mp_iota(_c)<N, F>
339template<std::size_t N, std::size_t F = 0> using mp_iota_c = mp_from_sequence<make_index_sequence<N>, mp_size_t<F>>;
340template<class N, class F = mp_int<0>> using mp_iota = mp_from_sequence<make_integer_sequence<typename std::remove_const<decltype(N::value)>::type, N::value>, F>;
341
342// mp_at(_c)<L, I>
343namespace detail
344{
345
346template<class L, std::size_t I> struct mp_at_c_impl;
347
348#if defined(BOOST_MP11_HAS_TYPE_PACK_ELEMENT)
349
350template<template<class...> class L, class... T, std::size_t I> struct mp_at_c_impl<L<T...>, I>
351{
352 using type = __type_pack_element<I, T...>;
353};
354
355#if defined(BOOST_MP11_HAS_TEMPLATE_AUTO)
356
357template<template<auto...> class L, auto... A, std::size_t I> struct mp_at_c_impl<L<A...>, I>
358{
359 using type = __type_pack_element<I, mp_value<A>...>;
360};
361
362#endif
363
364#else
365
366template<class L, std::size_t I> struct mp_at_c_impl
367{
368 using _map = mp_transform<mp_list, mp_iota<mp_size<L> >, mp_rename<L, mp_list>>;
369 using type = mp_second<mp_map_find<_map, mp_size_t<I> > >;
370};
371
372#endif
373
374#if BOOST_MP11_WORKAROUND( BOOST_MP11_CUDA, >= 9000000 && BOOST_MP11_CUDA < 10000000 )
375
376template<class L, std::size_t I> struct mp_at_c_cuda_workaround
377{
378 using type = mp_if_c<(I < mp_size<L>::value), detail::mp_at_c_impl<L, I>, void>;
379};
380
381#endif
382
383} // namespace detail
384
385#if BOOST_MP11_WORKAROUND( BOOST_MP11_CUDA, >= 9000000 && BOOST_MP11_CUDA < 10000000 )
386
387template<class L, std::size_t I> using mp_at_c = typename detail::mp_at_c_cuda_workaround< L, I >::type::type;
388
389#else
390
391template<class L, std::size_t I> using mp_at_c = typename mp_if_c<(I < mp_size<L>::value), detail::mp_at_c_impl<L, I>, void>::type;
392
393#endif
394
395template<class L, class I> using mp_at = mp_at_c<L, std::size_t{ I::value }>;
396
397// mp_take(_c)<L, N>
398namespace detail
399{
400
401template<std::size_t N, class L, class E = void> struct mp_take_c_impl
402{
403};
404
405template<template<class...> class L, class... T>
406struct mp_take_c_impl<0, L<T...>>
407{
408 using type = L<>;
409};
410
411template<template<class...> class L, class T1, class... T>
412struct mp_take_c_impl<1, L<T1, T...>>
413{
414 using type = L<T1>;
415};
416
417template<template<class...> class L, class T1, class T2, class... T>
418struct mp_take_c_impl<2, L<T1, T2, T...>>
419{
420 using type = L<T1, T2>;
421};
422
423template<template<class...> class L, class T1, class T2, class T3, class... T>
424struct mp_take_c_impl<3, L<T1, T2, T3, T...>>
425{
426 using type = L<T1, T2, T3>;
427};
428
429template<template<class...> class L, class T1, class T2, class T3, class T4, class... T>
430struct mp_take_c_impl<4, L<T1, T2, T3, T4, T...>>
431{
432 using type = L<T1, T2, T3, T4>;
433};
434
435template<template<class...> class L, class T1, class T2, class T3, class T4, class T5, class... T>
436struct mp_take_c_impl<5, L<T1, T2, T3, T4, T5, T...>>
437{
438 using type = L<T1, T2, T3, T4, T5>;
439};
440
441template<template<class...> class L, class T1, class T2, class T3, class T4, class T5, class T6, class... T>
442struct mp_take_c_impl<6, L<T1, T2, T3, T4, T5, T6, T...>>
443{
444 using type = L<T1, T2, T3, T4, T5, T6>;
445};
446
447template<template<class...> class L, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class... T>
448struct mp_take_c_impl<7, L<T1, T2, T3, T4, T5, T6, T7, T...>>
449{
450 using type = L<T1, T2, T3, T4, T5, T6, T7>;
451};
452
453template<template<class...> class L, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class... T>
454struct mp_take_c_impl<8, L<T1, T2, T3, T4, T5, T6, T7, T8, T...>>
455{
456 using type = L<T1, T2, T3, T4, T5, T6, T7, T8>;
457};
458
459template<template<class...> class L, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class... T>
460struct mp_take_c_impl<9, L<T1, T2, T3, T4, T5, T6, T7, T8, T9, T...>>
461{
462 using type = L<T1, T2, T3, T4, T5, T6, T7, T8, T9>;
463};
464
465template<template<class...> class L, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class... T, std::size_t N>
466struct mp_take_c_impl<N, L<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T...>, typename std::enable_if<N >= 10>::type>
467{
468 using type = mp_append<L<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>, typename mp_take_c_impl<N-10, L<T...>>::type>;
469};
470
471} // namespace detail
472
473template<class L, std::size_t N> using mp_take_c = mp_assign<L, typename detail::mp_take_c_impl<N, mp_rename<L, mp_list>>::type>;
474template<class L, class N> using mp_take = mp_take_c<L, std::size_t{ N::value }>;
475
476// mp_back<L>
477template<class L> using mp_back = mp_at_c<L, mp_size<L>::value - 1>;
478
479// mp_pop_back<L>
480template<class L> using mp_pop_back = mp_take_c<L, mp_size<L>::value - 1>;
481
482// mp_replace<L, V, W>
483namespace detail
484{
485
486template<class L, class V, class W> struct mp_replace_impl;
487
488template<template<class...> class L, class... T, class V, class W> struct mp_replace_impl<L<T...>, V, W>
489{
490#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, <= 1800 )
491 template<class A> struct _f { using type = mp_if<std::is_same<A, V>, W, A>; };
492 using type = L<typename _f<T>::type...>;
493#else
494 template<class A> using _f = mp_if<std::is_same<A, V>, W, A>;
495 using type = L<_f<T>...>;
496#endif
497};
498
499} // namespace detail
500
501template<class L, class V, class W> using mp_replace = typename detail::mp_replace_impl<L, V, W>::type;
502
503// mp_replace_if<L, P, W>
504namespace detail
505{
506
507template<class L, template<class...> class P, class W> struct mp_replace_if_impl;
508
509template<template<class...> class L, class... T, template<class...> class P, class W> struct mp_replace_if_impl<L<T...>, P, W>
510{
511#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, < 1920 )
512 template<class U> struct _f { using type = mp_if<P<U>, W, U>; };
513 using type = L<typename _f<T>::type...>;
514#else
515 template<class U> using _f = mp_if<P<U>, W, U>;
516 using type = L<_f<T>...>;
517#endif
518};
519
520} // namespace detail
521
522template<class L, template<class...> class P, class W> using mp_replace_if = typename detail::mp_replace_if_impl<L, P, W>::type;
523template<class L, class Q, class W> using mp_replace_if_q = mp_replace_if<L, Q::template fn, W>;
524
525// mp_copy_if<L, P>
526// in detail/mp_copy_if.hpp
527
528// mp_remove<L, V>
529namespace detail
530{
531
532template<class L, class V> struct mp_remove_impl;
533
534template<template<class...> class L, class... T, class V> struct mp_remove_impl<L<T...>, V>
535{
536#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, < 1920 )
537 template<class U> struct _f { using type = mp_if<std::is_same<U, V>, mp_list<>, mp_list<U>>; };
538 using type = mp_append<L<>, typename _f<T>::type...>;
539#else
540 template<class U> using _f = mp_if<std::is_same<U, V>, mp_list<>, mp_list<U>>;
541 using type = mp_append<L<>, _f<T>...>;
542#endif
543};
544
545} // namespace detail
546
547template<class L, class V> using mp_remove = typename detail::mp_remove_impl<L, V>::type;
548
549// mp_remove_if<L, P>
550// in detail/mp_remove_if.hpp
551
552// mp_flatten<L, L2 = mp_clear<L>>
553namespace detail
554{
555
556template<class L2> struct mp_flatten_impl
557{
558 template<class T> using fn = mp_if<mp_similar<L2, T>, T, mp_list<T>>;
559};
560
561} // namespace detail
562
563template<class L, class L2 = mp_clear<L>> using mp_flatten = mp_apply<mp_append, mp_push_front<mp_transform_q<detail::mp_flatten_impl<L2>, L>, mp_clear<L>>>;
564
565// mp_partition<L, P>
566namespace detail
567{
568
569template<class L, template<class...> class P> struct mp_partition_impl;
570
571template<template<class...> class L, class... T, template<class...> class P> struct mp_partition_impl<L<T...>, P>
572{
573 using type = L<mp_copy_if<L<T...>, P>, mp_remove_if<L<T...>, P>>;
574};
575
576} // namespace detail
577
578template<class L, template<class...> class P> using mp_partition = typename detail::mp_partition_impl<L, P>::type;
579template<class L, class Q> using mp_partition_q = mp_partition<L, Q::template fn>;
580
581// mp_sort<L, P>
582namespace detail
583{
584
585template<class L, template<class...> class P> struct mp_sort_impl;
586
587#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, <= 1800 )
588
589template<template<class...> class L, class... T, template<class...> class P> struct mp_sort_impl<L<T...>, P>
590{
591 static_assert( sizeof...(T) == 0, "T... must be empty" );
592 using type = L<>;
593};
594
595#else
596
597template<template<class...> class L, template<class...> class P> struct mp_sort_impl<L<>, P>
598{
599 using type = L<>;
600};
601
602#endif
603
604template<template<class...> class L, class T1, template<class...> class P> struct mp_sort_impl<L<T1>, P>
605{
606 using type = L<T1>;
607};
608
609template<template<class...> class L, class T1, class... T, template<class...> class P> struct mp_sort_impl<L<T1, T...>, P>
610{
611 template<class U> using F = P<U, T1>;
612
613 using part = mp_partition<L<T...>, F>;
614
615 using S1 = typename mp_sort_impl<mp_first<part>, P>::type;
616 using S2 = typename mp_sort_impl<mp_second<part>, P>::type;
617
618 using type = mp_append<mp_push_back<S1, T1>, S2>;
619};
620
621} // namespace detail
622
623template<class L, template<class...> class P> using mp_sort = typename detail::mp_sort_impl<L, P>::type;
624template<class L, class Q> using mp_sort_q = mp_sort<L, Q::template fn>;
625
626// mp_nth_element(_c)<L, I, P>
627namespace detail
628{
629
630template<class L, std::size_t I, template<class...> class P> struct mp_nth_element_impl;
631
632template<template<class...> class L, class T1, std::size_t I, template<class...> class P> struct mp_nth_element_impl<L<T1>, I, P>
633{
634 static_assert( I == 0, "mp_nth_element index out of range" );
635 using type = T1;
636};
637
638template<template<class...> class L, class T1, class... T, std::size_t I, template<class...> class P> struct mp_nth_element_impl<L<T1, T...>, I, P>
639{
640 static_assert( I < 1 + sizeof...(T), "mp_nth_element index out of range" );
641
642 template<class U> using F = P<U, T1>;
643
644 using part = mp_partition<L<T...>, F>;
645
646 using L1 = mp_first<part>;
647 static std::size_t const N1 = mp_size<L1>::value;
648
649 using L2 = mp_second<part>;
650
651#if BOOST_MP11_WORKAROUND( BOOST_MP11_CUDA, >= 9000000 && BOOST_MP11_CUDA < 10000000 )
652
653 struct detail
654 {
655 struct mp_nth_element_impl_cuda_workaround
656 {
657 using type = mp_cond<
658
659 mp_bool<(I < N1)>, mp_nth_element_impl<L1, I, P>,
660 mp_bool<(I == N1)>, mp_identity<T1>,
661 mp_true, mp_nth_element_impl<L2, I - N1 - 1, P>
662
663 >;
664 };
665 };
666
667 using type = typename detail::mp_nth_element_impl_cuda_workaround::type::type;
668
669#else
670
671 using type = typename mp_cond<
672
673 mp_bool<(I < N1)>, mp_nth_element_impl<L1, I, P>,
674 mp_bool<(I == N1)>, mp_identity<T1>,
675 mp_true, mp_nth_element_impl<L2, I - N1 - 1, P>
676
677 >::type;
678
679#endif
680};
681
682} // namespace detail
683
684template<class L, std::size_t I, template<class...> class P> using mp_nth_element_c = typename detail::mp_nth_element_impl<L, I, P>::type;
685template<class L, class I, template<class...> class P> using mp_nth_element = typename detail::mp_nth_element_impl<L, std::size_t{ I::value }, P>::type;
686template<class L, class I, class Q> using mp_nth_element_q = mp_nth_element<L, I, Q::template fn>;
687
688// mp_find<L, V>
689namespace detail
690{
691
692template<class L, class V> struct mp_find_impl;
693
694#if BOOST_MP11_CLANG && defined( BOOST_MP11_HAS_FOLD_EXPRESSIONS )
695
696struct mp_index_holder
697{
698 std::size_t i_;
699 bool f_;
700};
701
702constexpr inline mp_index_holder operator+( mp_index_holder const & v, bool f )
703{
704 if( v.f_ )
705 {
706 return v;
707 }
708 else if( f )
709 {
710 return { .i_: v.i_, .f_: true };
711 }
712 else
713 {
714 return { .i_: v.i_ + 1, .f_: false };
715 }
716}
717
718template<template<class...> class L, class... T, class V> struct mp_find_impl<L<T...>, V>
719{
720 static constexpr mp_index_holder _v{ .i_: 0, .f_: false };
721 using type = mp_size_t< (_v + ... + std::is_same<T, V>::value).i_ >;
722};
723
724#elif !defined( BOOST_MP11_NO_CONSTEXPR )
725
726template<template<class...> class L, class V> struct mp_find_impl<L<>, V>
727{
728 using type = mp_size_t<0>;
729};
730
731#if defined( BOOST_MP11_HAS_CXX14_CONSTEXPR )
732
733constexpr std::size_t cx_find_index( bool const * first, bool const * last )
734{
735 std::size_t m = 0;
736
737 while( first != last && !*first )
738 {
739 ++m;
740 ++first;
741 }
742
743 return m;
744}
745
746#else
747
748constexpr std::size_t cx_find_index( bool const * first, bool const * last )
749{
750 return first == last || *first? 0: 1 + cx_find_index( first + 1, last );
751}
752
753#endif
754
755template<template<class...> class L, class... T, class V> struct mp_find_impl<L<T...>, V>
756{
757 static constexpr bool _v[] = { std::is_same<T, V>::value... };
758 using type = mp_size_t< cx_find_index( _v, _v + sizeof...(T) ) >;
759};
760
761#else
762
763#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, <= 1800 )
764
765template<template<class...> class L, class... T, class V> struct mp_find_impl<L<T...>, V>
766{
767 static_assert( sizeof...(T) == 0, "T... must be empty" );
768 using type = mp_size_t<0>;
769};
770
771#else
772
773template<template<class...> class L, class V> struct mp_find_impl<L<>, V>
774{
775 using type = mp_size_t<0>;
776};
777
778#endif
779
780template<template<class...> class L, class... T, class V> struct mp_find_impl<L<V, T...>, V>
781{
782 using type = mp_size_t<0>;
783};
784
785template<template<class...> class L, class T1, class... T, class V> struct mp_find_impl<L<T1, T...>, V>
786{
787 using _r = typename mp_find_impl<mp_list<T...>, V>::type;
788 using type = mp_size_t<1 + _r::value>;
789};
790
791#endif
792
793} // namespace detail
794
795template<class L, class V> using mp_find = typename detail::mp_find_impl<L, V>::type;
796
797// mp_find_if<L, P>
798namespace detail
799{
800
801template<class L, template<class...> class P> struct mp_find_if_impl;
802
803#if BOOST_MP11_CLANG && defined( BOOST_MP11_HAS_FOLD_EXPRESSIONS )
804
805template<template<class...> class L, class... T, template<class...> class P> struct mp_find_if_impl<L<T...>, P>
806{
807 static constexpr mp_index_holder _v{ .i_: 0, .f_: false };
808 using type = mp_size_t< (_v + ... + P<T>::value).i_ >;
809};
810
811#elif !defined( BOOST_MP11_NO_CONSTEXPR )
812
813template<template<class...> class L, template<class...> class P> struct mp_find_if_impl<L<>, P>
814{
815 using type = mp_size_t<0>;
816};
817
818template<template<class...> class L, class... T, template<class...> class P> struct mp_find_if_impl<L<T...>, P>
819{
820 static constexpr bool _v[] = { P<T>::value... };
821 using type = mp_size_t< cx_find_index( _v, _v + sizeof...(T) ) >;
822};
823
824#else
825
826#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, <= 1800 )
827
828template<template<class...> class L, class... T, template<class...> class P> struct mp_find_if_impl<L<T...>, P>
829{
830 static_assert( sizeof...(T) == 0, "T... must be empty" );
831 using type = mp_size_t<0>;
832};
833
834#else
835
836template<template<class...> class L, template<class...> class P> struct mp_find_if_impl<L<>, P>
837{
838 using type = mp_size_t<0>;
839};
840
841#endif
842
843template<class L, template<class...> class P> struct mp_find_if_impl_2
844{
845 using _r = typename mp_find_if_impl<L, P>::type;
846 using type = mp_size_t<1 + _r::value>;
847};
848
849template<template<class...> class L, class T1, class... T, template<class...> class P> struct mp_find_if_impl<L<T1, T...>, P>
850{
851 using type = typename mp_if<P<T1>, mp_identity<mp_size_t<0>>, mp_find_if_impl_2<mp_list<T...>, P>>::type;
852};
853
854#endif
855
856} // namespace detail
857
858template<class L, template<class...> class P> using mp_find_if = typename detail::mp_find_if_impl<L, P>::type;
859template<class L, class Q> using mp_find_if_q = mp_find_if<L, Q::template fn>;
860
861// mp_reverse<L>
862namespace detail
863{
864
865template<class L> struct mp_reverse_impl;
866
867#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, <= 1800 )
868
869template<template<class...> class L, class... T> struct mp_reverse_impl<L<T...>>
870{
871 static_assert( sizeof...(T) == 0, "T... must be empty" );
872 using type = L<>;
873};
874
875#else
876
877template<template<class...> class L> struct mp_reverse_impl<L<>>
878{
879 using type = L<>;
880};
881
882#endif
883
884template<template<class...> class L, class T1> struct mp_reverse_impl<L<T1>>
885{
886 using type = L<T1>;
887};
888
889template<template<class...> class L, class T1, class T2> struct mp_reverse_impl<L<T1, T2>>
890{
891 using type = L<T2, T1>;
892};
893
894template<template<class...> class L, class T1, class T2, class T3> struct mp_reverse_impl<L<T1, T2, T3>>
895{
896 using type = L<T3, T2, T1>;
897};
898
899template<template<class...> class L, class T1, class T2, class T3, class T4> struct mp_reverse_impl<L<T1, T2, T3, T4>>
900{
901 using type = L<T4, T3, T2, T1>;
902};
903
904template<template<class...> class L, class T1, class T2, class T3, class T4, class T5> struct mp_reverse_impl<L<T1, T2, T3, T4, T5>>
905{
906 using type = L<T5, T4, T3, T2, T1>;
907};
908
909template<template<class...> class L, class T1, class T2, class T3, class T4, class T5, class T6> struct mp_reverse_impl<L<T1, T2, T3, T4, T5, T6>>
910{
911 using type = L<T6, T5, T4, T3, T2, T1>;
912};
913
914template<template<class...> class L, class T1, class T2, class T3, class T4, class T5, class T6, class T7> struct mp_reverse_impl<L<T1, T2, T3, T4, T5, T6, T7>>
915{
916 using type = L<T7, T6, T5, T4, T3, T2, T1>;
917};
918
919template<template<class...> class L, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8> struct mp_reverse_impl<L<T1, T2, T3, T4, T5, T6, T7, T8>>
920{
921 using type = L<T8, T7, T6, T5, T4, T3, T2, T1>;
922};
923
924template<template<class...> class L, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9> struct mp_reverse_impl<L<T1, T2, T3, T4, T5, T6, T7, T8, T9>>
925{
926 using type = L<T9, T8, T7, T6, T5, T4, T3, T2, T1>;
927};
928
929template<template<class...> class L, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class... T> struct mp_reverse_impl<L<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T...>>
930{
931 using type = mp_push_back<typename mp_reverse_impl<L<T...>>::type, T10, T9, T8, T7, T6, T5, T4, T3, T2, T1>;
932};
933
934} // namespace detail
935
936template<class L> using mp_reverse = typename detail::mp_reverse_impl<L>::type;
937
938// mp_fold<L, V, F>
939// in detail/mp_fold.hpp
940
941// mp_reverse_fold<L, V, F>
942namespace detail
943{
944
945template<class L, class V, template<class...> class F> struct mp_reverse_fold_impl;
946
947#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, <= 1800 )
948
949template<template<class...> class L, class... T, class V, template<class...> class F> struct mp_reverse_fold_impl<L<T...>, V, F>
950{
951 static_assert( sizeof...(T) == 0, "T... must be empty" );
952 using type = V;
953};
954
955#else
956
957template<template<class...> class L, class V, template<class...> class F> struct mp_reverse_fold_impl<L<>, V, F>
958{
959 using type = V;
960};
961
962#endif
963
964template<template<class...> class L, class T1, class... T, class V, template<class...> class F> struct mp_reverse_fold_impl<L<T1, T...>, V, F>
965{
966 using rest = typename mp_reverse_fold_impl<L<T...>, V, F>::type;
967 using type = F<T1, rest>;
968};
969
970template<template<class...> class L, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class... T, class V, template<class...> class F> struct mp_reverse_fold_impl<L<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T...>, V, F>
971{
972 using rest = typename mp_reverse_fold_impl<L<T...>, V, F>::type;
973 using type = F<T1, F<T2, F<T3, F<T4, F<T5, F<T6, F<T7, F<T8, F<T9, F<T10, rest> > > > > > > > > >;
974};
975
976} // namespace detail
977
978template<class L, class V, template<class...> class F> using mp_reverse_fold = typename detail::mp_reverse_fold_impl<L, V, F>::type;
979template<class L, class V, class Q> using mp_reverse_fold_q = mp_reverse_fold<L, V, Q::template fn>;
980
981// mp_unique<L>
982namespace detail
983{
984
985template<class L> struct mp_unique_impl;
986
987template<template<class...> class L, class... T> struct mp_unique_impl<L<T...>>
988{
989 using type = mp_set_push_back<L<>, T...>;
990};
991
992} // namespace detail
993
994template<class L> using mp_unique = typename detail::mp_unique_impl<L>::type;
995
996// mp_unique_if<L, P>
997namespace detail
998{
999
1000template<template<class...> class P> struct mp_unique_if_push_back
1001{
1002 template<class...> struct impl
1003 {
1004 };
1005
1006 template<template<class...> class L, class... Ts, class T>
1007 struct impl<L<Ts...>, T>
1008 {
1009 using type = mp_if<mp_any<P<Ts, T>...>, L<Ts...>, L<Ts..., T>>;
1010 };
1011
1012 template<class... T> using fn = typename impl<T...>::type;
1013};
1014
1015} // namespace detail
1016
1017template<class L, template<class...> class P>
1018using mp_unique_if = mp_fold_q<L, mp_clear<L>, detail::mp_unique_if_push_back<P>>;
1019
1020template<class L, class Q> using mp_unique_if_q = mp_unique_if<L, Q::template fn>;
1021
1022// mp_all_of<L, P>
1023template<class L, template<class...> class P> using mp_all_of = mp_bool< mp_count_if<L, P>::value == mp_size<L>::value >;
1024template<class L, class Q> using mp_all_of_q = mp_all_of<L, Q::template fn>;
1025
1026// mp_none_of<L, P>
1027template<class L, template<class...> class P> using mp_none_of = mp_bool< mp_count_if<L, P>::value == 0 >;
1028template<class L, class Q> using mp_none_of_q = mp_none_of<L, Q::template fn>;
1029
1030// mp_any_of<L, P>
1031template<class L, template<class...> class P> using mp_any_of = mp_bool< mp_count_if<L, P>::value != 0 >;
1032template<class L, class Q> using mp_any_of_q = mp_any_of<L, Q::template fn>;
1033
1034// mp_replace_at_c<L, I, W>
1035namespace detail
1036{
1037
1038template<class L, class I, class W> struct mp_replace_at_impl
1039{
1040 static_assert( I::value >= 0, "mp_replace_at<L, I, W>: I must not be negative" );
1041
1042 template<class T1, class T2> using _p = std::is_same<T2, mp_size_t<I::value>>;
1043 template<class T1, class T2> using _f = W;
1044
1045 using type = mp_transform_if<_p, _f, L, mp_iota<mp_size<L> > >;
1046};
1047
1048} // namespace detail
1049
1050template<class L, class I, class W> using mp_replace_at = typename detail::mp_replace_at_impl<L, I, W>::type;
1051template<class L, std::size_t I, class W> using mp_replace_at_c = typename detail::mp_replace_at_impl<L, mp_size_t<I>, W>::type;
1052
1053//mp_for_each<L>(f)
1054namespace detail
1055{
1056
1057template<class... T, class F> BOOST_MP11_CONSTEXPR F mp_for_each_impl( mp_list<T...>, F && f )
1058{
1059 using A = int[sizeof...(T)];
1060 return (void)A{ ((void)f(T()), 0)... }, std::forward<F>(f);
1061}
1062
1063template<class F> BOOST_MP11_CONSTEXPR F mp_for_each_impl( mp_list<>, F && f )
1064{
1065 return std::forward<F>(f);
1066}
1067
1068} // namespace detail
1069
1070#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, >= 1900 )
1071
1072// msvc has a limit of 1024
1073
1074template<class L, class F> BOOST_MP11_CONSTEXPR mp_if_c<mp_size<L>::value <= 1024, F> mp_for_each( F && f )
1075{
1076 return detail::mp_for_each_impl( mp_rename<L, mp_list>(), std::forward<F>(f) );
1077}
1078
1079template<class L, class F> BOOST_MP11_CONSTEXPR mp_if_c<mp_size<L>::value >= 1025, F> mp_for_each( F && f )
1080{
1081 using L2 = mp_rename<L, mp_list>;
1082
1083 using L3 = mp_take_c<L2, 1024>;
1084 using L4 = mp_drop_c<L2, 1024>;
1085
1086 return mp_for_each<L4>( mp_for_each<L3>( std::forward<F>(f) ) );
1087}
1088
1089#else
1090
1091template<class L, class F> BOOST_MP11_CONSTEXPR F mp_for_each( F && f )
1092{
1093 return detail::mp_for_each_impl( mp_rename<L, mp_list>(), std::forward<F>(f) );
1094}
1095
1096#endif
1097
1098// mp_insert<L, I, T...>
1099template<class L, class I, class... T> using mp_insert = mp_append<mp_take<L, I>, mp_push_front<mp_drop<L, I>, T...>>;
1100
1101// mp_insert_c<L, I, T...>
1102template<class L, std::size_t I, class... T> using mp_insert_c = mp_append<mp_take_c<L, I>, mp_push_front<mp_drop_c<L, I>, T...>>;
1103
1104// mp_erase<L, I, J>
1105template<class L, class I, class J> using mp_erase = mp_append<mp_take<L, I>, mp_drop<L, J>>;
1106
1107// mp_erase_c<L, I, J>
1108template<class L, std::size_t I, std::size_t J> using mp_erase_c = mp_append<mp_take_c<L, I>, mp_drop_c<L, J>>;
1109
1110// mp_starts_with<L1, L2>
1111// contributed by Glen Joseph Fernandes (glenjofe@gmail.com)
1112namespace detail {
1113
1114template<class L1, class L2>
1115struct mp_starts_with_impl { };
1116
1117template<template<class...> class L1, class... T1, template<class...> class L2,
1118 class... T2>
1119struct mp_starts_with_impl<L1<T1...>, L2<T2...> > {
1120 template<class L>
1121 static mp_false check(L);
1122
1123 template<class... T>
1124 static mp_true check(mp_list<T2..., T...>);
1125
1126 using type = decltype(check(mp_list<T1...>()));
1127};
1128
1129} // namespace detail
1130
1131template<class L1, class L2>
1132using mp_starts_with = typename detail::mp_starts_with_impl<L1, L2>::type;
1133
1134// mp_rotate_left(_c)<L, N>
1135namespace detail
1136{
1137
1138// limit divisor to 1 to avoid division by 0 and give a rotation of 0 for lists containing 0 or 1 elements
1139template<std::size_t Ln, std::size_t N> using canonical_left_rotation = mp_size_t<N % (Ln == 0? 1: Ln)>;
1140
1141// perform right rotation as a left rotation by inverting the number of elements to rotate
1142template<std::size_t Ln, std::size_t N> using canonical_right_rotation = mp_size_t<Ln - N % (Ln == 0? 1: Ln)>;
1143
1144// avoid errors when rotating fixed-sized lists by using mp_list for the transformation
1145template<class L, class N, class L2 = mp_rename<L, mp_list>> using mp_rotate_impl = mp_assign<L, mp_append< mp_drop<L2, N>, mp_take<L2, N> >>;
1146
1147} // namespace detail
1148
1149template<class L, std::size_t N> using mp_rotate_left_c = detail::mp_rotate_impl<L, detail::canonical_left_rotation<mp_size<L>::value, N>>;
1150template<class L, class N> using mp_rotate_left = mp_rotate_left_c<L, std::size_t{ N::value }>;
1151
1152// mp_rotate_right(_c)<L, N>
1153template<class L, std::size_t N> using mp_rotate_right_c = mp_rotate_left<L, detail::canonical_right_rotation<mp_size<L>::value, N>>;
1154template<class L, class N> using mp_rotate_right = mp_rotate_right_c<L, std::size_t{ N::value }>;
1155
1156// mp_min_element<L, P>
1157// mp_max_element<L, P>
1158// in detail/mp_min_element.hpp
1159
1160// mp_power_set<L>
1161namespace detail
1162{
1163
1164template<class L> struct mp_power_set_impl;
1165
1166} // namespace detail
1167
1168template<class L> using mp_power_set = typename detail::mp_power_set_impl<L>::type;
1169
1170namespace detail
1171{
1172
1173#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, <= 1800 )
1174
1175template<template<class...> class L, class... T> struct mp_power_set_impl< L<T...> >
1176{
1177 static_assert( sizeof...(T) == 0, "T... must be empty" );
1178 using type = L< L<> >;
1179};
1180
1181#else
1182
1183template<template<class...> class L> struct mp_power_set_impl< L<> >
1184{
1185 using type = L< L<> >;
1186};
1187
1188#endif
1189
1190template<template<class...> class L, class T1, class... T> struct mp_power_set_impl< L<T1, T...> >
1191{
1192 using S1 = mp_power_set< L<T...> >;
1193
1194 template<class L2> using _f = mp_push_front<L2, T1>;
1195
1196 using S2 = mp_transform<_f, S1>;
1197
1198 using type = mp_append< S1, S2 >;
1199};
1200
1201} // namespace detail
1202
1203// mp_partial_sum<L, V, F>
1204namespace detail
1205{
1206
1207template<template<class...> class F> struct mp_partial_sum_impl_f
1208{
1209#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, <= 1900 )
1210
1211 template<class V, class T> using fn = mp_list<F<mp_first<V>, T>, mp_push_back<mp_second<V>, F<mp_first<V>, T>> >;
1212
1213#else
1214
1215 template<class V, class T, class N = F<mp_first<V>, T>> using fn = mp_list<N, mp_push_back<mp_second<V>, N>>;
1216
1217#endif
1218};
1219
1220} // namespace detail
1221
1222template<class L, class V, template<class...> class F> using mp_partial_sum = mp_second<mp_fold_q<L, mp_list<V, mp_clear<L>>, detail::mp_partial_sum_impl_f<F>> >;
1223template<class L, class V, class Q> using mp_partial_sum_q = mp_partial_sum<L, V, Q::template fn>;
1224
1225// mp_iterate<V, F, R>
1226namespace detail
1227{
1228
1229template<class V, template<class...> class F, template<class...> class R, class N> struct mp_iterate_impl;
1230
1231} // namespace detail
1232
1233template<class V, template<class...> class F, template<class...> class R> using mp_iterate = typename detail::mp_iterate_impl<V, F, R, mp_valid<R, V>>::type;
1234
1235namespace detail
1236{
1237
1238template<class V, template<class...> class F, template<class...> class R> struct mp_iterate_impl<V, F, R, mp_false>
1239{
1240 template<class X> using _f = mp_list<F<X>>;
1241 using type = mp_eval_or<mp_list<>, _f, V>;
1242};
1243
1244template<class V, template<class...> class F, template<class...> class R> struct mp_iterate_impl<V, F, R, mp_true>
1245{
1246 using type = mp_push_front<mp_iterate<R<V>, F, R>, F<V>>;
1247};
1248
1249} // namespace detail
1250
1251template<class V, class Qf, class Qr> using mp_iterate_q = mp_iterate<V, Qf::template fn, Qr::template fn>;
1252
1253// mp_pairwise_fold<L, F>
1254namespace detail
1255{
1256
1257template<class L, class Q> using mp_pairwise_fold_impl = mp_transform_q<Q, mp_pop_back<L>, mp_pop_front<L>>;
1258
1259} // namespace detail
1260
1261template<class L, class Q> using mp_pairwise_fold_q = mp_eval_if<mp_empty<L>, mp_clear<L>, detail::mp_pairwise_fold_impl, L, Q>;
1262template<class L, template<class...> class F> using mp_pairwise_fold = mp_pairwise_fold_q<L, mp_quote<F>>;
1263
1264// mp_intersperse<L, S>
1265namespace detail
1266{
1267
1268template<class L, class S> struct mp_intersperse_impl
1269{
1270};
1271
1272#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, <= 1800 )
1273
1274template<template<class...> class L, class... T, class S> struct mp_intersperse_impl<L<T...>, S>
1275{
1276 static_assert( sizeof...(T) == 0, "T... must be empty" );
1277 using type = L<>;
1278};
1279
1280#else
1281
1282template<template<class...> class L, class S> struct mp_intersperse_impl<L<>, S>
1283{
1284 using type = L<>;
1285};
1286
1287#endif
1288
1289template<template<class...> class L, class T1, class... T, class S> struct mp_intersperse_impl<L<T1, T...>, S>
1290{
1291 using type = mp_append<L<T1>, L<S, T>...>;
1292};
1293
1294} // namespace detail
1295
1296template<class L, class S> using mp_intersperse = typename detail::mp_intersperse_impl<L, S>::type;
1297
1298// mp_split<L, S>
1299namespace detail
1300{
1301
1302template<class L, class S, class J> struct mp_split_impl;
1303
1304} // namespace detail
1305
1306template<class L, class S> using mp_split = typename detail::mp_split_impl<L, S, mp_find<L, S>>::type;
1307
1308namespace detail
1309{
1310
1311template<class L, class S, class J> using mp_split_impl_ = mp_push_front<mp_split<mp_drop_c<L, J::value + 1>, S>, mp_take<L, J>>;
1312
1313template<class L, class S, class J> struct mp_split_impl
1314{
1315 using type = mp_eval_if_c<mp_size<L>::value == J::value, mp_push_back<mp_clear<L>, L>, mp_split_impl_, L, S, J>;
1316};
1317
1318} // namespace detail
1319
1320// mp_join<L, S>
1321
1322template<class L, class S> using mp_join = mp_apply<mp_append, mp_intersperse<L, mp_list<S>>>;
1323
1324} // namespace mp11
1325} // namespace boost
1326
1327#endif // #ifndef BOOST_MP11_ALGORITHM_HPP_INCLUDED
1328