├── .travis.yml
├── API_REFERENCE.md
├── CMakeLists.txt
├── LICENSE.md
├── README.md
├── examples
    ├── CMakeLists.txt
    ├── concat.cpp
    ├── reverse_polish.cpp
    ├── safe_mean.cpp
    └── switch_bools.cpp
├── include
    ├── CMakeLists.txt
    └── vta
    │   └── algorithms.hpp
└── tests
    ├── CMakeLists.txt
    ├── algorithms.cpp
    └── main.cpp


/.travis.yml:
--------------------------------------------------------------------------------
 1 | language:
 2 |    - cpp
 3 | 
 4 | compiler:
 5 |    - gcc
 6 |     
 7 | before_install:
 8 |    - sudo add-apt-repository ppa:ubuntu-toolchain-r/test -y
 9 |    - sudo add-apt-repository -y ppa:boost-latest/ppa
10 |    - sudo apt-get update -qq
11 |    - sudo apt-get install -qq libboost1.55-all-dev
12 |    - if [ "$CXX" = "clang++" ]; then sudo apt-get install -qq libstdc++-4.9-dev; fi
13 |    - if [ "$CXX" = "g++" ]; then sudo apt-get install -qq g++-4.9; fi
14 |    - if [ "$CXX" = "g++" ]; then export CXX="g++-4.9" CC="gcc-4.9"; fi
15 | 
16 | script:
17 |    - mkdir build
18 |    - cd build
19 |    - cmake ..
20 |    - make -j5
21 |    - ctest --output-on-failure
22 | 


--------------------------------------------------------------------------------
/API_REFERENCE.md:
--------------------------------------------------------------------------------
  1 | VTA API Reference
  2 | =================
  3 | 
  4 |  * [Predicates](#predicate)
  5 |  * [Miscellaneous Functions](#misc)
  6 |  * [Type aliases](#alias)
  7 |  * [Variadic Functors](#functor)
  8 |  * [Tranformations](#transformation)
  9 |  * [Macros](#macro)
 10 | 
 11 | <a name="predicate"></a>Predicates
 12 | ----------
 13 | 
 14 | VTA contains similar tools to those found in `<type_traits>` to decide whether one or more types have a certain property.
 15 | 
 16 | ---
 17 | #### `are_same`
 18 | ```cpp
 19 | template <typename... Args>
 20 | struct are_same {
 21 |     static bool const value;
 22 | };
 23 | ```
 24 | 
 25 | This struct is an extension of `std::is_same` that operates on multiple types. `value` is `true` only if all of the types `Args...` are the same, `false` otherwise. If there are 0 or 1 types, then `value` is always `true`.
 26 | 
 27 | ##### example
 28 | ```cpp
 29 | static_assert(vta::are_same<float, float, float, float>::value, "");
 30 | static_assert(!vta::are_same<int, int, double>::value, "");
 31 | ```
 32 | 
 33 | ---
 34 | #### `are_same_after`
 35 | ```cpp
 36 | template <typename TypeTransformation, typename... Args>
 37 | struct are_same_after {
 38 |     static bool const value
 39 |       = vta::are_same<typename TypeTransformation<Args>::type...>::value;
 40 | };
 41 | ```
 42 | 
 43 | This struct is a shorthand way to apply a type transformation to all of `Args...` and the variable `value` is the result of whether these are all the same type or not.
 44 | 
 45 | ##### example
 46 | ```cpp
 47 | static_assert(vta::are_same_after<std::decay, int, int&, const int&>::value, "");
 48 | ```
 49 | 
 50 | ---
 51 | #### `are_unique`
 52 | ```cpp
 53 | template <typename... Args>
 54 | struct are_unique{
 55 |     static bool const value;
 56 | };
 57 | ```
 58 | 
 59 | `value` is true if and only if all `Args...` are unique types
 60 | 
 61 | ##### example
 62 | ```cpp
 63 | static_assert(vta::are_unique<int, float, double>::value, "");
 64 | static_assert(!vta::are_unique<int, int, double>::value, "");
 65 | ```
 66 | 
 67 | ---
 68 | #### `are_unique_after`
 69 | ```cpp
 70 | template <typename TypeTransformation, typename... Args>
 71 | struct are_unique_after{
 72 |     static bool const value
 73 |       = vta::are_unique<typename TypeTransformation<Args>::type...>::value;
 74 | };
 75 | ```
 76 | 
 77 | This struct is a shorthand way to apply a type transformation to all of `Args...` and the variable `value` is the result of whether all of these are unique.
 78 | 
 79 | ##### example
 80 | ```cpp
 81 | static_assert(!vta::are_unique_after<std::remove_reference, int, int&, int&&>::value, "");
 82 | ```
 83 | 
 84 | ---
 85 | #### `are_unique_ints`
 86 | ```cpp
 87 | template <int... Ns>
 88 | struct are_unique_ints {
 89 |     static bool const value;
 90 | };
 91 | ```
 92 | 
 93 | `value` is true if no `int` that appears in `Ns...` appears more than once.
 94 | 
 95 | ##### examples
 96 | ```cpp
 97 | static_assert(vta::are_unique_ints<1, 2, 3>::value, "");
 98 | static_assert(!vta::are_unique_ints<1, 2, 3, 2>::value, "");
 99 | ```
100 | 
101 | <a name="misc"></a>Miscellaneous Functions
102 | ---------
103 | Some of the signatures of functions and classes are not 100% correct C++, but they are written this way for clarity (for example `vta::last` and `vta::at`).
104 | 
105 | ---
106 | #### `head`
107 | ```cpp
108 | template <typename Head, typename... Args>
109 | constexpr Head&& head(Head&&, Args&&...) noexcept;
110 | ```
111 | 
112 | Returns a reference to the first argument with the same value category it had when it was passed in to `head`.
113 | 
114 | ##### examples
115 | ```cpp
116 | std::string s = vta::head("hello", 1, '2');       // s = "hello"
117 | std::string t = vta::head(std::move(s), "world"); // s is moved into t
118 | ```
119 | 
120 | ---
121 | #### `last`
122 | ```cpp
123 | template <typename... Args, typename Last>
124 | constexpr Last&& head(Args&&..., Last&&) noexcept;
125 | ```
126 | 
127 | Returns a reference to the last argument with the same value category it had when it was passed in to `last`.
128 | 
129 | ##### examples
130 | ```cpp
131 | int i = vta::last('1', 2); // i = 2
132 | ```
133 | 
134 | ---
135 | #### `at`
136 | ```cpp
137 | template <int N, typename... Before, typename Arg, typename... After>
138 | constexpr Arg&& at(Before&&..., Arg&&, After&&...) noexcept;
139 | ```
140 | 
141 | Returns a reference to the `N`-th argument with the same value category it had when it was passed in to `at`. Negative values of `N` are allowed and these count backwards from the last argument. e.g. `at<-1>` returns the last parameter and `at<-2>` returns the penultimate parameter.
142 | 
143 | ##### examples
144 | ```cpp
145 | int i = vta::at<1>('1', 2, "3");          // i = 2
146 | std::string s = vta::at<-1>('1', 2, "3"); // s = "3"
147 | char c = vta::at<-3>('1', 2, "3");        // c = '1'
148 | ```
149 | 
150 | ---
151 | #### `add_const`
152 | ```cpp
153 | template <typename T>
154 | constexpr T const& add_const(T&&) noexcept;
155 | ```
156 | 
157 | When dealing with variadic functors created by this library, the `const` overload of `operator()` is `constexpr` and the non-`const` is not. In `constexpr` functions it is necessary to use the `const` overload, `add_const` is very useful in these situations.
158 | 
159 | ##### examples
160 | ```cpp
161 | auto sum = [](auto l, auto r){ return l + r; };
162 | 
163 | template <typename Args...>
164 | constexpr auto sum(Args... args) {
165 |     return vta::add_const(vta::foldl(sum))(0, args...);
166 | }
167 | ```
168 | 
169 | <a name="alias"></a>Type aliases
170 | ------------
171 | 
172 | #### `head_t`
173 | ```cpp
174 | template <typename... Args>
175 | using head_t = decltype(head(std::declval<Args>()...));
176 | ```
177 | 
178 | `head_t` is a type alias for the first type in `Args...`.
179 | 
180 | ---
181 | #### `last_t`
182 | ```cpp
183 | template <typename... Args>
184 | using last_t = decltype(last(std::declval<Args>()...));
185 | ```
186 | 
187 | `last_t` is a type alias for the last type in `Args...`.
188 | 
189 | ---
190 | #### `at_t`
191 | ```cpp
192 | template <int N>
193 | struct at_t {
194 |     template <typename... Args>
195 |     using type = decltype(at<N>(std::declval<Args>()...));
196 | };
197 | ```
198 | 
199 | `at_t<N>::type` is a type alias for the `N`th type in `Args...`.
200 | 
201 | <a name="functor"></a>Variadic Functor functions
202 | --------------------------
203 | 
204 | The following functions in the Variadic Template Algorithm library create a variadic functor. These functors have an unspecified type, but have the following member function signatures.
205 | 
206 | ```cpp
207 | struct /*unspecified*/ {
208 |     template <typename... Args>
209 |     constexpr /*depends*/ operator()(Args&&... args) const;
210 | 
211 |     template <typename... Args>
212 |     /*depends*/ operator()(Args&&... args);
213 | };
214 | ```
215 | 
216 | The return type of `operator()` differs and will be specified for each function.
217 | 
218 | Like the standard library, all functions in VTA may copy functors that are passed to it an unspecified number of times. If you want to have reference semantics for functors, use `std::ref` and `std::cref` in `<functional>`. No copies of other parameters passed are ever copied, only references are passed around.
219 | 
220 | For example:
221 | 
222 | ```cpp
223 | // functor can be copied any number of times, whereas arg1, arg2, ... never
224 | // have copies made and are only ever forwarded
225 | vta::map(functor)(arg1, arg2, arg3, arg4);
226 | ```
227 | 
228 | When discussed, the index of parameters always begins at 0.
229 | 
230 | More than std::numeric_limits<int>::max() parameters may not be passed to any variadic functor (though this situation is unlikely to ever happen naturally, and I'm sure would struggle to compile regardless).
231 | 
232 | The variadic functors created are copyable/movable if the function they are created with is copyable/movable.
233 | 
234 | ---
235 | #### `map`
236 | ```cpp
237 | template <typename Function>
238 | constexpr /*VariadicFunctor*/ map(Function&& f);
239 | ```
240 | 
241 |  `map` returns a functor that, when applied to any number of parameters, applies the function `f` to each parameter in order. This functor always returns `void`.
242 | 
243 | ##### examples
244 | ```cpp
245 | auto printer = [](auto const& x){ std::cout << x; };
246 | vta::map(printer)("I can count to", 4, '!'); // prints "I can count to 4!"
247 | ```
248 | 
249 | ---
250 | #### `foldl`
251 | ```cpp
252 | template <typename Function>
253 | constexpr /*VariadicFunctor*/ foldl(Function&& f);
254 | ```
255 | 
256 | `foldl` returns a variadic functor that performs a left fold across it's parameters. If the parameters `arg1`, `arg2`, ..., `argN` are passed, the functor returns `f(...f(f(arg1, arg2), arg3), ...), argN)`. If one parameter is passed, it is the value returned. This variadic functor does not work with 0 parameters.
257 | 
258 | ##### examples
259 | ```cpp
260 | auto append = [](std::string const& s, auto x){
261 |     std::stringstream ss;
262 |     ss << s << x;
263 |     return ss.str();
264 | };
265 | 
266 | std::string str = vta::foldl(append)("", 1, ',', 2, " and ", 3);
267 | std::cout << str; // prints "1,2 and 3"
268 | ```
269 | 
270 | ---
271 | #### `foldr`
272 | ```cpp
273 | template <typename Function>
274 | constexpr /*VariadicFunctor*/ foldr(Function&& f);
275 | ```
276 | 
277 | `foldr` returns a variadic functor that performs a right fold across it's parameters. If the parameters `arg1`, `arg2`, ..., `argM`, `argN` are passed, the functor returns `f(arg1, f(arg2, f(... f(argM, argN)...)`. If one parameter is passed, it is the value returned. This variadic functor does not work with 0 parameters.
278 | 
279 | ##### examples
280 | ```cpp
281 | auto subtract = [](auto l, auto r){ return l - r; };
282 | 
283 | // prints -2 = (0 - (1 - (2 - 3)))
284 | std::cout << vta::foldr(subtract)(0, 1, 2, 3);
285 | ```
286 | 
287 | ---
288 | #### `all_of`
289 | ```cpp
290 | template <typename Function>
291 | constexpr /*VariadicFunctor*/ all_of(Function&& f);
292 | ```
293 | 
294 | `all_of` returns a variadic functor that returns `true` if and only if `f(a)` returns `true` (or any type convertible to `true`) for all arguments. `f` is applied to the arguments in order. If `f(b)` returns `false` for some parameter `b`, then `f` is no longer applied to the rest of the arguments.
295 | 
296 | ##### examples
297 | ```cpp
298 | struct is_positve_int {
299 |     bool operator()(int i) const { return i > 0; }
300 | 
301 |     template <typename T>
302 |     bool operator()(T const&) const { return false; }
303 | };
304 | 
305 | bool x = vta::all_of(is_positive_int{})(1, 2, 3);    // x = true
306 | bool y = vta::all_of(is_positive_int{})(-4, 2, "s"); // y = false
307 | bool z = vta::all_of(is_positive_int{})('2', 0);     // z = false
308 | ```
309 | 
310 | ---
311 | #### `any_of`
312 | ```cpp
313 | template <typename Function>
314 | constexpr /*VariadicFunctor*/ any_of(Function&& f);
315 | ```
316 | 
317 | `any_of` returns a variadic functor that returns `true` if and only if `f(a)` returns `true` (or any type convertible to `true`) for any argument `a`. `f` is applied to the arguments in order. If `f(b)` does return `true` for some parameter `b`, then `f` is no longer applied to the rest of the arguments.
318 | 
319 | ##### examples
320 | ```cpp
321 | struct is_positve_int; // see definition under all_of documentation
322 | 
323 | bool x = vta::any_of(is_positive_int{})(1, 2, 3);    // x = true
324 | bool y = vta::any_of(is_positive_int{})(-4, 2, "s"); // y = true
325 | bool z = vta::any_of(is_positive_int{})('2', 0);     // z = false
326 | ```
327 | 
328 | ---
329 | #### `none_of`
330 | ```cpp
331 | template <typename Function>
332 | constexpr /*VariadicFunctor*/ none_of(Function&& f);
333 | ```
334 | 
335 | `any_of` returns a variadic functor that returns `true` if and only if `f(a)` returns `false` (or any type convertible to `false`) for all arguments. `f` is applied to the arguments in order. If `f(b)` returns `true` for some parameter `b`, then `f` is no longer applied to the rest of the arguments.
336 | 
337 | 
338 | ##### examples
339 | ```cpp
340 | struct is_positve_int; // see definition under all_of documentation
341 | 
342 | bool x = vta::any_of(is_positive_int{})(1, 2, 3);    // x = false
343 | bool y = vta::any_of(is_positive_int{})(-4, 2, "s"); // y = false
344 | bool z = vta::any_of(is_positive_int{})('2', 0);     // z = true
345 | ```
346 | 
347 | ---
348 | #### `forward_after`
349 | ```cpp
350 | template <typename Function, typename Transformation>
351 | constexpr /*VariadicFunctor*/ forward_after(Function&& f);
352 | ```
353 | 
354 | Returns a variadic functor that forwards all of it's arguments to `f` after applying transformation `Transformation`. Documentation of available transformation are below.
355 | 
356 | ```cpp
357 | auto minus = [](auto l, auto r){ return l - r; };
358 | 
359 | // vta::id performs no transformation
360 | int a = vta::forward_after<vta::id>(minus)(4, 2);      // a = 2
361 | 
362 | // vta::flip swaps the first two arguments
363 | int b = vta::forward_after<vta::flip>(minus)(4, 2); // b = -2
364 | 
365 | // prints "4321" as vta::reverse reverses the arguments
366 | auto printer = [](auto const& x){ std::cout << x; };
367 | vta::forward_after<vta::reverse>(vta::map(printer))(1, 2, '3', "4");
368 | ```
369 | 
370 | <a name="transformation"></a>Transformations
371 | ---------------
372 | 
373 | Transformations are types that are passed to `forward_after` in order to permute and filters the parameters before fowarding them on. All transformations must have the following `static` function,
374 | 
375 | ```cpp
376 | struct Transformation {
377 |     template <typename Function, typename... Args>
378 |     static auto tranform(Function&&, Args&&...);
379 | };
380 | ```
381 | 
382 | The `tranform` function calls `f` with some or all of `args...` after applying some permutation and/or transformation.
383 | 
384 | All transformations in VTA have a `constexpr` `transform` function so are available to use in `constexpr` functions.
385 | 
386 | #### `id`
387 | ```cpp
388 | struct id;
389 | ```
390 | 
391 | `id` forward all arguments without modification.
392 | 
393 | ##### examples
394 | ```cpp
395 | // prints "1234"
396 | auto printer = [](auto const& x){ std::cout << x; };
397 | std::forward_after<vta::id>(vta::map(printer))(1, 2u, '3', "4");
398 | ```
399 | 
400 | ---
401 | #### `call_if`
402 | ```cpp
403 | template <bool Condition>
404 | struct call_if
405 | ```
406 | 
407 | `call_if` calls the function only if `Condition` is `true`, otherwise noop.
408 | 
409 | ##### examples
410 | ```cpp
411 | // prints "1234"
412 | auto printer = [](auto const& x){ std::cout << x; };
413 | std::forward_after<vta::call_if<true>>(vta::map(printer))(1, 2u, '3', "4");
414 | 
415 | // prints nothing
416 | std::forward_after<vta::call_if<false>>(vta::map(printer))(1, 2u, '3', "4");
417 | ```
418 | 
419 | ---
420 | #### `flip`
421 | ```cpp
422 | struct flip;
423 | ```
424 | 
425 | `flip` swaps the first and second parameter.
426 | 
427 | ##### examples
428 | ```cpp
429 | // prints "2134"
430 | auto printer = [](auto const& x){ std::cout << x; };
431 | std::forward_after<vta::flip>(vta::map(printer))(1, 2u, '3', "4");
432 | ```
433 | 
434 | ---
435 | #### `left_shift`
436 | ```cpp
437 | template <unsigned N>
438 | struct left_shift;
439 | ```
440 | 
441 | `left_shift` cyclic shifts the parameters `N` places to the left. `N` must be between 0 and the number of parameters passed to `forward_after` otherwise it will fail to compile.
442 | 
443 | ##### examples
444 | ```cpp
445 | // prints "2341"
446 | auto printer = [](auto const& x){ std::cout << x; };
447 | std::forward_after<vta::left_shift<1u>>(vta::map(printer))(1, 2u, '3', "4");
448 | ```
449 | 
450 | ---
451 | #### `right_shift`
452 | ```cpp
453 | template <unsigned N>
454 | struct right_shift;
455 | ```
456 | 
457 | `right_shift` cyclic shifts the parameters `N` places to the right. `N` must be between 0 and the number of parameters passed to `forward_after` otherwise it will fail to compile.
458 | 
459 | ##### examples
460 | ```cpp
461 | // prints "4123"
462 | auto printer = [](auto const& x){ std::cout << x; };
463 | std::forward_after<vta::right_shift<1u>>(vta::map(printer))(1, 2u, '3', "4");
464 | ```
465 | 
466 | ---
467 | #### `shift`
468 | ```cpp
469 | template <int N>
470 | struct shift;
471 | ```
472 | 
473 | If `N` is greater than 0, `shift<N>` is the same as `left_shift<N>`, if `N` is less than 0, it is the same as `right_shift<-N>`. If `N` equals 0, then the arguments are forwarded without permutation.
474 | 
475 | ---
476 | #### `left_shift_tail`
477 | ```cpp
478 | template <unsigned N>
479 | struct left_shift_tail;
480 | ```
481 | 
482 | ##### examples
483 | ```cpp
484 | // prints "1342"
485 | auto printer = [](auto const& x){ std::cout << x; };
486 | std::forward_after<vta::left_shift_tail<1u>>(vta::map(printer))(1, 2u, '3', "4");
487 | ```
488 | 
489 | `left_shift_tail` cyclic shifts the all parameters but the first, `N` places to the left. `N` must be between 0 and 1 - the number of parameters passed to `forward_after` otherwise it will fail to compile.
490 | 
491 | ---
492 | #### `right_shift_tail`
493 | ```cpp
494 | template <unsigned N>
495 | struct right_shift_tail;
496 | ```
497 | 
498 | `right_shift_tail` cyclic shifts the all parameters but the first, `N` places to the right. `N` must be between 0 and 1 - the number of parameters passed to `forward_after` otherwise it will fail to compile.
499 | 
500 | ##### examples
501 | ```cpp
502 | // prints "1423"
503 | auto printer = [](auto const& x){ std::cout << x; };
504 | std::forward_after<vta::right_shift_tail<1u>>(vta::map(printer))(1, 2u, '3', "4");
505 | ```
506 | 
507 | ---
508 | #### `shift_tail`
509 | ```cpp
510 | template <int N>
511 | struct shift_tail;
512 | ```
513 | 
514 | If `N` is greater than 0, `shift_tail<N>` is the same as `left_shift_tail<N>`, if `N` is less than 0, it is the same as `right_shift_tail<-N>`. If `N` equals 0, then the arguments are forwarded without permutation.
515 | 
516 | ---
517 | #### `drop`
518 | ```cpp
519 | template <unsigned N>
520 | struct drop;
521 | ```
522 | 
523 | If `N` is positive,`drop` forwards all but the first `N` arguments. `N` must be less than the number of parameters passed otherwise it will fail to compile. If `N` is negative, `drop` forwards all but the first `-N` arguments.
524 | 
525 | ##### examples
526 | ```cpp
527 | // prints "34"
528 | auto printer = [](auto const& x){ std::cout << x; };
529 | std::forward_after<vta::drop<2>>(vta::map(printer))(1, 2u, '3', "4");
530 | 
531 | // prints "234"
532 | std::forward_after<vta::drop<-1>>(vta::map(printer))(1, 2u, '3', "4");
533 | ```
534 | 
535 | ---
536 | #### `take`
537 | ```cpp
538 | template <int N>
539 | struct take;
540 | ```
541 | 
542 | If `N` is positive,`take` forwards only the first `N` arguments. `N` must be less than the number of parameters passed otherwise it will fail to compile. If `N` is negative, `take` forwards all but the last `-N` arguments.
543 | 
544 | ##### examples
545 | ```cpp
546 | // prints "123"
547 | auto printer = [](auto const& x){ std::cout << x; };
548 | std::forward_after<vta::take<3>>(vta::map(printer))(1, 2u, '3', "4");
549 | 
550 | // prints "1"
551 | std::forward_after<vta::take<-3>>(vta::map(printer))(1, 2u, '3', "4");
552 | ```
553 | 
554 | ---
555 | #### `slice`
556 | ```cpp
557 | template <int N, int M>
558 | struct slice;
559 | ```
560 | 
561 | `slice` forwards the arguments with an index inclusively between `N` and `M`. If `N` is negative (or `M` is negative) it counts backwards from the end of the parameters, e.g. -1 is the index of the last parameter. If `N > M` (after accounting for negative indices) then `slice` will fail to compile.
562 | 
563 | ##### examples
564 | ```cpp
565 | // prints "23"
566 | auto printer = [](auto const& x){ std::cout << x; };
567 | std::forward_after<vta::slice<1, 2>>(vta::map(printer))(1, 2u, '3', "4");
568 | 
569 | // prints "123"
570 | std::forward_after<vta::slice<0, -2>>(vta::map(printer))(1, 2u, '3', "4");
571 | 
572 | // prints ""
573 | std::forward_after<vta::slice<3, -1>>(vta::map(printer))(1, 2u, '3', "4");
574 | ```
575 | 
576 | ---
577 | #### `swap`
578 | ```cpp
579 | template <int N, int M>
580 | struct swap;
581 | ```
582 | 
583 | `swap` exchanges the two parameters at position `N` and `M`. If this position is negative, it is counted backwards from the end of the parameters, e.g. -1 is the index of the last parameter.
584 | 
585 | ##### examples
586 | ```cpp
587 | // prints "3214"
588 | auto printer = [](auto const& x){ std::cout << x; };
589 | std::forward_after<vta::swap<0, 2>>(vta::map(printer))(1, 2u, '3', "4");
590 | 
591 | // prints "4231"
592 | auto printer = [](auto const& x){ std::cout << x; };
593 | std::forward_after<vta::swap<0, -1>>(vta::map(printer))(1, 2u, '3', "4");
594 | ```
595 | 
596 | ---
597 | #### `cycle`
598 | ```cpp
599 | template <int... Ns>
600 | struct cycle;
601 | ```
602 | 
603 | `cycle` permutes the parameters at the positions `Ns...` using [cycle notation](http://en.wikipedia.org/wiki/Cycle_notation). Remember that indexing starts from 0, rather than starting from 1, which is more commonly used in mathematics literature. If any positions are negative, it is counted backwards from the end of the parameters, e.g. -1 is the index of the last parameter.
604 | 
605 | All indexes must be unique. `cycle<0, 1, 1>` will not compile. `cycle<-1, 3>` will not compile if there are 4 arguments passed to `forward_after` since -1 and 3 describe the same index.
606 | 
607 | ##### examples
608 | ```cpp
609 | // prints "4213"
610 | auto printer = [](auto const& x){ std::cout << x; };
611 | std::forward_after<vta::cycle<0, 2, 3>>(vta::map(printer))(1, 2u, '3', "4");
612 | 
613 | // prints "4213"
614 | std::forward_after<vta::cycle<-1, 1, 0, 2>>(vta::map(printer))(1, 2u, '3', "4");
615 | ```
616 | 
617 | ---
618 | #### `reverse`
619 | ```cpp
620 | struct reverse;
621 | ```
622 | 
623 | `reverse` reverses the order of the arguments passed.
624 | 
625 | ##### examples
626 | ```cpp
627 | // prints "4321"
628 | auto printer = [](auto const& x){ std::cout << x; };
629 | std::forward_after<vta::reverse>>(vta::map(printer))(1, 2u, '3', "4");
630 | ```
631 | 
632 | ---
633 | #### `filter`
634 | ```cpp
635 | template <typename Filter>
636 | struct filter;
637 | ```
638 | 
639 | `filter` only forwards on a type `Arg` if `Filter<Arg>::value` is `true`. Most structs in `<type_traits>` are appropriate as a filter. An example filter:
640 | 
641 | ```cpp
642 | template <typename T>
643 | struct ExampleFilter {
644 |     static bool const value = std::is_enum<T>::value &&
645 |                               std::is_class<T>::value;
646 | };
647 | ```
648 | 
649 | ##### examples
650 | ```cpp
651 | // prints "123"
652 | auto printer = [](auto const& x){ std::cout << x; };
653 | std::forward_after<vta::filter<std::is_integral>>(vta::map(printer))(1, 2u, '3', "4");
654 | ```
655 | 
656 | ---
657 | #### `compose`
658 | ```cpp
659 | template <typename... Tranformations>
660 | struct compose;
661 | ```
662 | 
663 | `compose` creates a new transformation that would occur after applying all `Transformations...` in order.
664 | 
665 | ##### examples
666 | ```cpp
667 | // prints "2431"
668 | auto printer = [](auto const& x){ std::cout << x; };
669 | std::forward_after<vta::compose<vta::flip,     // would be "2134"
670 |                                 vta::shift<1>, // would be "1342"
671 |                                 vta::reverse   // prints "2431"
672 |                                >(vta::map(printer))(1, 2u, '3', "4");
673 | ```
674 | 
675 | <a name="macro"></a>Macros
676 | ------
677 | 
678 | #### `VTA_FN_TO_FUNCTOR`
679 | ```cpp
680 | #define VTA_FN_TO_FUNCTOR(...) [](auto&&... args) \
681 |   -> decltype(auto){ return __VA_ARGS__(std::forward<decltype(args)>(args)...); }
682 | ```
683 | 
684 | `VTA_FN_TO_FUNCTOR` creates a lambda that calls the function that was passed as an argument. This is a workaround for passing templated functions, such as `std::max` that would require specifying the type. This macro has been provided by [Florian Weber](http://florianjw.de/en/passing_overloaded_functions.html).
685 | 
686 | ##### examples
687 | ```cpp
688 | template <typename... Args>
689 | auto max(Args... args) {
690 |     return vta::foldl(VTA_FN_TO_FUNCTOR(std::max))(args...);
691 | }
692 | ```
693 | 


--------------------------------------------------------------------------------
/CMakeLists.txt:
--------------------------------------------------------------------------------
1 | cmake_minimum_required (VERSION 2.6)
2 | project(VariadicTemplateAlgorithms)
3 | set(VariadicTemplateAlgorithms_VERSION_MAJOR 0)
4 | set(VariadicTemplateAlgorithms_VERSION_MINOR 1)
5 | enable_testing()
6 | add_subdirectory(examples)
7 | add_subdirectory(include)
8 | add_subdirectory(tests)
9 | 


--------------------------------------------------------------------------------
/LICENSE.md:
--------------------------------------------------------------------------------
 1 | Boost Software License - Version 1.0 - August 17th, 2003
 2 | 
 3 | Permission is hereby granted, free of charge, to any person or organization
 4 | obtaining a copy of the software and accompanying documentation covered by
 5 | this license (the "Software") to use, reproduce, display, distribute,
 6 | execute, and transmit the Software, and to prepare derivative works of the
 7 | Software, and to permit third-parties to whom the Software is furnished to
 8 | do so, all subject to the following:
 9 | 
10 | The copyright notices in the Software and this entire statement, including
11 | the above license grant, this restriction and the following disclaimer,
12 | must be included in all copies of the Software, in whole or in part, and
13 | all derivative works of the Software, unless such copies or derivative
14 | works are solely in the form of machine-executable object code generated by
15 | a source language processor.
16 | 
17 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19 | FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
20 | SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
21 | FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
22 | ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
23 | DEALINGS IN THE SOFTWARE.


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | Variadic Template Algorithms
 2 | ============================
 3 | 
 4 | [![Build Status](https://travis-ci.org/elliotgoodrich/VariadicTemplateAlgorithms.svg?branch=master)](https://travis-ci.org/elliotgoodrich/VariadicTemplateAlgorithms)
 5 | 
 6 | Working with parameter packs in C++ can be difficult. Getting a reference to the last argument of a parameter pack or reversing the order of arguments to a function is much harder than it should be. VTA is a header-only C++14 library to make this easier.
 7 | 
 8 | Grabbing the nth parameter is very simple with `vta::head`, `vta::at`, and `vta::last`:
 9 | 
10 | ```cpp
11 | auto i = vta::head(1, "hello"s, 3.14, '!');   // i is an int with value 1
12 | auto c = vta::last(1, "hello"s, 3.14, '!');   // l is a char with value '!'
13 | auto s = vta::at<1>(1, "hello"s, 3.14, '!');  // s is a std::string with value "hello"
14 | 
15 | // vta::at can take negative values to index backward from the end
16 | auto d = vta::at<-2>(1, "hello"s, 3.14, '!'); // d is a double with value 3.14
17 | ```
18 | 
19 | There are many functions which return functors that apply a function across any number of arguments. Writing a max function is simple when you can [fold](http://en.wikipedia.org/wiki/Fold_%28higher-order_function%29) across any number of parameters,
20 | 
21 | ```cpp
22 | template <typename... Args>
23 | auto max(Args... args) {
24 | 	// Check that all of the arguments are of the same type
25 | 	static_assert(vta::are_same<typename std::decay<Args...>::type>::value,
26 | 	  "Arguments to max must have the same type");
27 | 
28 | 	// Create a max lambda that can operate on any type
29 | 	// (note this line is not needed if the VTA_FN_TO_FUNCTOR macro is used)
30 | 	auto max = [](auto const& l, auto const& r){ return std::max(l, r); };
31 | 
32 | 	// Perform a left fold across the arguments, returning the maximum
33 | 	return vta::foldl(max)(args...);
34 | }
35 | ```
36 | 
37 | Reversing arguments and forwarding them on is also easy,
38 | 
39 | ```cpp
40 | // Prints an argument
41 | auto printer = [](auto const& x){ std::cout << x; };
42 | 
43 | // Prints all arguments in order
44 | template <typename... Args>
45 | void print(Args... args) {
46 | 	// vta::map applies a function to each argument in order
47 | 	vta::map(printer)(args...);
48 | }
49 | 
50 | // Prints all arguments in reverse order
51 | template <typename... Args>
52 | void reverse_print(Args... args) {
53 | 	// vta::forward_after forwards the arguments to a function after a transformation
54 | 	vta::forward_after<vta::reverse>(vta::map(printer))(args...);
55 | }
56 | ```
57 | 
58 | The `vta::forward_after` function can perform many other transformations such as swapping arguments or shifting all arguments to the left. The full list of transformation can be found in the [api reference](API_REFERENCE.md#transformations).
59 | 


--------------------------------------------------------------------------------
/examples/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | if(CMAKE_COMPILER_IS_GNUCC)
 2 |   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -pedantic -Wextra -Werror -std=c++1y")
 3 | endif()
 4 | 
 5 | if(MINGW)
 6 |   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mwindows")
 7 | endif()
 8 | 
 9 | include_directories(../include/)
10 | 
11 | add_executable(concat concat.cpp)
12 | add_executable(reverse_polish reverse_polish.cpp)
13 | add_executable(safe_mean safe_mean.cpp)
14 | add_executable(switch_bools switch_bools.cpp)
15 | 


--------------------------------------------------------------------------------
/examples/concat.cpp:
--------------------------------------------------------------------------------
 1 | #include "vta/algorithms.hpp"
 2 | 
 3 | #include <cstring>
 4 | #include <iostream>
 5 | #include <string>
 6 | #include <utility>
 7 | 
 8 | std::size_t string_size(std::string const& str) noexcept { return str.size(); }
 9 | std::size_t string_size(char const* str) noexcept { return std::strlen(str); }
10 | std::size_t string_size(char) noexcept { return 1; }
11 | 
12 | auto const sum = [](auto lhs, auto rhs){ return lhs + rhs; };
13 | 
14 | template <typename... Args>
15 | std::string concat(Args&&... args) {
16 | 	std::string str;
17 | 	str.reserve(vta::foldl(sum)(0ul, string_size(args)...));
18 | 	vta::map([&str](auto const& append){ str += append; })(args...);
19 | 	return str;
20 | }
21 | 
22 | int main() {
23 | 	std::string name = "World";
24 | 	auto const hello_world = concat("Hello ", name, '!');
25 | 	std::cout << hello_world << std::endl;
26 | }
27 | 


--------------------------------------------------------------------------------
/examples/reverse_polish.cpp:
--------------------------------------------------------------------------------
 1 | #include "vta/algorithms.hpp"
 2 | 
 3 | #include <stdexcept>
 4 | #include <iostream>
 5 | #include <type_traits>
 6 | 
 7 | struct start_type {};
 8 | static constexpr start_type start{};
 9 | 
10 | struct add_type {};
11 | static constexpr add_type add{};
12 | 
13 | struct minus_type {};
14 | static constexpr minus_type minus{};
15 | 
16 | struct mult_type {};
17 | static constexpr mult_type mult{};
18 | 
19 | struct div_type {};
20 | static constexpr div_type divide{};
21 | 
22 | struct fact_type {};
23 | static constexpr fact_type fact{};
24 | 
25 | template <typename T, typename std::enable_if<std::is_arithmetic<T>::value>* = nullptr>
26 | struct polish_calculator {
27 | 	constexpr T operator()(std::pair<T, T> stack, add_type) noexcept {
28 | 		return stack.first + stack.second;
29 | 	}
30 | 
31 | 	constexpr T operator()(std::pair<T, T> stack, minus_type) noexcept {
32 | 		return stack.first - stack.second;
33 | 	}
34 | 
35 | 	constexpr T operator()(std::pair<T, T> stack, mult_type) noexcept {
36 | 		return stack.first * stack.second;
37 | 	}
38 | 
39 | 	constexpr T operator()(std::pair<T, T> stack, div_type) noexcept {
40 | 		return stack.first / stack.second;
41 | 	}
42 | 
43 | 	// Only allow factorial if the type is integral (e.g. disable for double)
44 | 	// This function can only throw if T is signed, so mark as noexcept otherwise
45 | 	constexpr auto operator()(T stack, fact_type) noexcept(std::is_unsigned<T>::value)
46 | 	  -> typename std::enable_if<std::is_integral<T>::value, T>::type {
47 | 		return (stack < 0) ? throw std::runtime_error{"Negative value passed to factorial"}
48 | 		                   : (stack == 0) ? 1 : stack * (*this)(stack - 1, fact);
49 | 	}
50 | 
51 | 	constexpr std::pair<T, T> operator()(T first, T second) noexcept {
52 | 		return {first, second};
53 | 	}
54 | 
55 | 	constexpr T operator()(start_type, T second) noexcept {
56 | 		return second;
57 | 	}
58 | };
59 | 
60 | // This function can only throw if call factorial on a signed value, so mark as nothrow if we
61 | // are operating on an unsigned type or fact_type is not in Args...
62 | template <typename T, typename... Args>
63 | constexpr T rev_polish_calc(Args... args)
64 |   noexcept(std::is_unsigned<T>::value || vta::are_unique<fact_type, Args...>::value) {
65 | 	return vta::add_const(vta::foldl(polish_calculator<T>{}))(start, args...);
66 | }
67 | 
68 | int main()
69 | {
70 | 	std::cout << "2 3 + = " << rev_polish_calc<int>(2, 3, add) << std::endl;
71 | 	std::cout << "1 4 * = " << rev_polish_calc<int>(1, 4, mult) << std::endl;
72 | 	std::cout << "5 2 - 7 * = " << rev_polish_calc<int>(5, 2, minus, 5, mult) << std::endl;
73 | 	std::cout << "15 4 / 1 + = " << rev_polish_calc<int>(15, 4, divide, 1, add) << std::endl;
74 | 
75 | 	static_assert(rev_polish_calc<int>(3, fact, 2, minus, 8, mult, 2, add) == 34,
76 | 	  "3 ! 2 - 8 * 2 + should equal 34");
77 | }
78 | 


--------------------------------------------------------------------------------
/examples/safe_mean.cpp:
--------------------------------------------------------------------------------
 1 | #include "vta/algorithms.hpp"
 2 | 
 3 | #include <limits>
 4 | #include <iostream>
 5 | #include <type_traits>
 6 | 
 7 | template <typename T, int Size>
 8 | struct running {
 9 | 	T total;
10 | 	T remainder;
11 | };
12 | 
13 | template <typename T, int N>
14 | constexpr running<T, N> safe_mean_foldl(running<T, N> r, T t) noexcept {
15 | 	return running<T, N>{(r.total + t / N) + (r.remainder + t % N) / N,
16 | 	                     (r.remainder + t % N) % N};
17 | }
18 | 
19 | template <typename Arg,
20 |           typename... Args,
21 |           int N = sizeof...(Args) + 1,
22 |           typename std::enable_if<vta::are_same_after<std::decay, Arg, Args...>::value
23 |                                && std::is_arithmetic<Arg>::value>::type* = nullptr>
24 | constexpr Arg safe_mean(Arg arg, Args... args) noexcept {
25 | 	return vta::add_const(vta::foldl(&safe_mean_foldl<Arg, N>))
26 | 	  (running<Arg, N>{0, 0}, arg, args...).total;
27 | }
28 | 
29 | template <typename Arg, typename... Args>
30 | void print_mean(Arg first, Args... args) {
31 | 	std::cout << "Arithmetic mean of " << first;
32 | 	vta::map([](auto x){ std::cout << ", " << x; })(args...);
33 | 	std::cout << " is ";
34 | 	std::cout << safe_mean(first, args...);
35 | 	std::cout << std::endl;
36 | }
37 | 
38 | template <typename T>
39 | constexpr T sum(T lhs, T rhs) noexcept {
40 | 	return lhs + rhs;
41 | }
42 | 
43 | template <typename Arg,
44 |           typename... Args,
45 |           int N = sizeof...(Args) + 1,
46 |           typename std::enable_if<vta::are_same_after<std::decay, Arg, Args...>::value
47 |                                && std::is_arithmetic<Arg>::value>::type* = nullptr>
48 | constexpr Arg unsafe_mean(Arg arg, Args... args) noexcept {
49 | 	return vta::add_const(vta::foldl(&sum<Arg>))(arg, args...) / N;
50 | }
51 | 
52 | int main()
53 | {
54 | 	print_mean(1);
55 | 	print_mean(1, 2);
56 | 	print_mean(-7, -8);
57 | 	print_mean(1, 2, 3);
58 | 	print_mean(-1, 15, 2, -3, 0, 0, 2, 3);
59 | 
60 | 	static_assert(safe_mean(1, 2) == 1, "");
61 | 	static_assert(safe_mean(std::numeric_limits<int>::max(), std::numeric_limits<int>::max() - 2)
62 | 	  == std::numeric_limits<int>::max() - 1, "");
63 | 
64 | 	static_assert(unsafe_mean(1, 2) == 1, "");
65 | 	// following line may not compile due to integer overflow
66 | 	//static_assert(unsafe_mean(std::numeric_limits<int>::max(), std::numeric_limits<int>::max() - 2)
67 | 	  //== std::numeric_limits<int>::max() - 1, "");
68 | }
69 | 


--------------------------------------------------------------------------------
/examples/switch_bools.cpp:
--------------------------------------------------------------------------------
 1 | #include "vta/algorithms.hpp"
 2 | 
 3 | #include <climits>
 4 | #include <iostream>
 5 | #include <random>
 6 | #include <type_traits>
 7 | 
 8 | constexpr int calculate_switch(int a, bool b) noexcept { return 2 * a + b; }
 9 | 
10 | template <typename... Bools>
11 | constexpr int switch_bools(Bools... bools) noexcept {
12 | 	static_assert(sizeof...(bools) < sizeof(int) * CHAR_BIT, "Too many parameters to switch_bools");
13 | 	static_assert(vta::are_same_after<std::decay, bool, Bools...>::value, "");
14 | 	return vta::add_const(vta::foldl(&calculate_switch))(0, bools...);
15 | }
16 | 
17 | int main() {
18 | 	std::random_device rd;
19 | 	std::mt19937 eng{rd()};
20 | 	std::uniform_int_distribution<> generate(0, 1);
21 | 	bool const a = generate(eng);
22 | 	bool const b = generate(eng);
23 | 	bool const c = generate(eng);
24 | 
25 | 	switch(switch_bools(a, b, c)) {
26 | 		case switch_bools(false, false, false): std::cout << "FFF"; break;
27 | 		case switch_bools(false, false, true):  std::cout << "FFT"; break;
28 | 		case switch_bools(false, true,  false): std::cout << "FTF"; break;
29 | 		case switch_bools(false, true,  true):  std::cout << "FTT"; break;
30 | 		case switch_bools(true,  false, false): std::cout << "TFF"; break;
31 | 		case switch_bools(true,  false, true):  std::cout << "TFT"; break;
32 | 		case switch_bools(true,  true,  false): std::cout << "TTF"; break;
33 | 		case switch_bools(true,  true,  true):  std::cout << "TTT"; break;
34 | 	}
35 | 
36 | 	std::cout << std::endl;
37 | }
38 | 


--------------------------------------------------------------------------------
/include/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | cmake_minimum_required(VERSION 2.6)
 2 | 
 3 | include_directories(.)
 4 | 
 5 | set(SOURCES
 6 | 	vta/algorithms.hpp
 7 | )
 8 | 
 9 | add_library(HEADER_ONLY_TARGET STATIC ${SOURCES})
10 | set_target_properties(HEADER_ONLY_TARGET PROPERTIES LINKER_LANGUAGE CXX)
11 | 


--------------------------------------------------------------------------------
/include/vta/algorithms.hpp:
--------------------------------------------------------------------------------
  1 | /******************************************************************//**
  2 |  * \file   algorithms.hpp
  3 |  * \author Elliot Goodrich
  4 |  *
  5 |  * Boost Software License - Version 1.0 - August 17th, 2003
  6 |  *
  7 |  * Permission is hereby granted, free of charge, to any person or organization
  8 |  * obtaining a copy of the software and accompanying documentation covered by
  9 |  * this license (the "Software") to use, reproduce, display, distribute,
 10 |  * execute, and transmit the Software, and to prepare derivative works of the
 11 |  * Software, and to permit third-parties to whom the Software is furnished to
 12 |  * do so, all subject to the following:
 13 |  *
 14 |  * The copyright notices in the Software and this entire statement, including
 15 |  * the above license grant, this restriction and the following disclaimer,
 16 |  * must be included in all copies of the Software, in whole or in part, and
 17 |  * all derivative works of the Software, unless such copies or derivative
 18 |  * works are solely in the form of machine-executable object code generated by
 19 |  * a source language processor.
 20 |  *
 21 |  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 22 |  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 23 |  * FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
 24 |  * SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
 25 |  * FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
 26 |  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 27 |  * DEALINGS IN THE SOFTWARE.
 28 |  *********************************************************************/
 29 | 
 30 | #ifndef INCLUDE_GUARD_12E75493_BA12_4EF3_B0D8_92747A030D0E
 31 | #define INCLUDE_GUARD_12E75493_BA12_4EF3_B0D8_92747A030D0E
 32 | 
 33 | #include <type_traits>
 34 | #include <utility>
 35 | 
 36 | namespace vta {
 37 | 
 38 | // Returns the size of the parameter pack as an integer
 39 | template <typename... Args>
 40 | constexpr int count(Args&&...) noexcept {
 41 | 	return sizeof...(Args);
 42 | }
 43 | 
 44 | /**************************************************************************************************
 45 |  * Macro                                                                                          *
 46 |  **************************************************************************************************/
 47 | 
 48 | // Provided by Florian Weber (http://florianjw.de/en/passing_overloaded_functions.html)
 49 | #define VTA_FN_TO_FUNCTOR(...) [](auto&&... args) \
 50 |   -> decltype(auto){ return __VA_ARGS__(std::forward<decltype(args)>(args)...); }
 51 | 
 52 | /**************************************************************************************************
 53 |  * Predicates                                                                                     *
 54 |  **************************************************************************************************/
 55 | 
 56 | /** are_same */
 57 | template <typename... Args>
 58 | struct are_same;
 59 | 
 60 | template <typename First, typename Second, typename... Args>
 61 | struct are_same<First, Second, Args...> {
 62 | 	static bool const value = std::is_same<First, Second>::value
 63 | 	                       && are_same<Second, Args...>::value;
 64 | };
 65 | 
 66 | template <typename Arg>
 67 | struct are_same<Arg> : public std::true_type {};
 68 | 
 69 | template <>
 70 | struct are_same<> : public std::true_type {};
 71 | 
 72 | /** are_same_after */
 73 | template <template<class> class TypeTransformation, typename... Args>
 74 | struct are_same_after {
 75 | 	static bool const value = vta::are_same<typename TypeTransformation<Args>::type...>::value;
 76 | };
 77 | 
 78 | /** are_unique_ints */
 79 | template <int... Ns>
 80 | struct are_unique_ints;
 81 | 
 82 | template <>
 83 | struct are_unique_ints<> {
 84 | 	static bool const value = true;
 85 | };
 86 | 
 87 | template <int N>
 88 | struct are_unique_ints<N> {
 89 | 	static bool const value = true;
 90 | };
 91 | 
 92 | template <int M, int N, int... Ns>
 93 | struct are_unique_ints<M, N, Ns...> {
 94 | 	static bool const value = (M != N)
 95 | 	                        && are_unique_ints<M, Ns...>::value
 96 | 	                        && are_unique_ints<N, Ns...>::value;
 97 | };
 98 | 
 99 | /** are_unique */
100 | template <typename... Args>
101 | struct are_unique;
102 | 
103 | template <>
104 | struct are_unique<> {
105 | 	static bool const value = true;
106 | };
107 | 
108 | template <typename Arg>
109 | struct are_unique<Arg> {
110 | 	static bool const value = true;
111 | };
112 | 
113 | template <typename Arg1, typename Arg2, typename... Args>
114 | struct are_unique<Arg1, Arg2, Args...> {
115 | 	static bool const value = (!std::is_same<Arg1, Arg2>::value)
116 | 	                        && are_unique<Arg1, Args...>::value
117 | 	                        && are_unique<Arg2, Args...>::value;
118 | };
119 | 
120 | /** are_unique_after */
121 | template <template<class> class TypeTransformation, typename... Args>
122 | struct are_unique_after {
123 | 	static bool const value = vta::are_unique<typename TypeTransformation<Args>::type...>::value;
124 | };
125 | 
126 | // Forward after
127 | template <typename Function, typename Transformation>
128 | class forward_after_f {
129 | 	Function mF;
130 | 
131 | public:
132 | 	constexpr forward_after_f(Function f)
133 | 	: mF(std::move(f)) {
134 | 	}
135 | 
136 | 	template <typename... Args>
137 | 	constexpr auto operator()(Args&&... args) const {
138 | 		return Transformation::transform(mF, std::forward<Args>(args)...);
139 | 	}
140 | 
141 | 	template <typename... Args>
142 | 	auto operator()(Args&&... args) {
143 | 		return Transformation::transform(mF, std::forward<Args>(args)...);
144 | 	}
145 | };
146 | 
147 | template <typename Transformation, typename Function>
148 | constexpr forward_after_f<Function, Transformation> forward_after(Function&& f) {
149 | 	return {std::forward<Function>(f)};
150 | }
151 | 
152 | /**************************************************************************************************
153 |  * Transformations                                                                                *
154 |  **************************************************************************************************/
155 | 
156 | namespace detail {
157 | 
158 | template <typename Function, typename... Transforms>
159 | class compose_helper_f;
160 | 
161 | template <typename Function, typename FirstTransform, typename... Transforms>
162 | class compose_helper_f<Function, FirstTransform, Transforms...> {
163 | 	Function mF;
164 | 
165 | public:
166 | 	constexpr compose_helper_f(Function f)
167 | 	: mF(std::move(f)) {
168 | 	}
169 | 
170 | 	template <typename... Args>
171 | 	constexpr auto operator()(Args&&... args) const {
172 | 		return FirstTransform::transform(compose_helper_f<Function, Transforms...>{mF},
173 | 		                                 std::forward<Args>(args)...);
174 | 	}
175 | 
176 | 	template <typename... Args>
177 | 	auto operator()(Args&&... args) {
178 | 		return FirstTransform::transform(compose_helper_f<Function, Transforms...>{mF},
179 | 		                                 std::forward<Args>(args)...);
180 | 	}
181 | };
182 | 
183 | template <typename Function>
184 | class compose_helper_f<Function> {
185 | 	Function mF;
186 | 
187 | public:
188 | 	compose_helper_f(Function f)
189 | 	: mF(std::move(f)) {
190 | 	}
191 | 
192 | 	template <typename... Args>
193 | 	constexpr auto operator()(Args&&... args) const {
194 | 		return mF(std::forward<Args>(args)...);
195 | 	}
196 | 
197 | 	template <typename... Args>
198 | 	auto operator()(Args&&... args) {
199 | 		return mF(std::forward<Args>(args)...);
200 | 	}
201 | };
202 | 
203 | }
204 | 
205 | /** Composes a sequence of transformations. */
206 | template <typename... Transforms>
207 | struct compose {
208 | 	template <typename Function, typename... Args>
209 | 	constexpr static auto transform(Function&& f, Args&&... args) {
210 | 		typedef detail::compose_helper_f<typename std::remove_reference<Function>::type, Transforms...> Helper;
211 | 		return Helper{f}(std::forward<Args>(args)...);
212 | 	}
213 | };
214 | 
215 | /** Forwards the arguments to f without change. */
216 | struct id {
217 | 	template <typename Function, typename... Args>
218 | 	constexpr static auto transform(Function&& f, Args&&... args) {
219 | 		return std::forward<Function>(f)(std::forward<Args>(args)...);
220 | 	}
221 | };
222 | 
223 | /** Calls the function with the given arguments if Condition is true. */
224 | template <bool Condition>
225 | struct call_if;
226 | 
227 | template <>
228 | struct call_if<true> {
229 | 	template <typename Function, typename... Args>
230 | 	constexpr static auto transform(Function&& f, Args&&... args) {
231 | 		return id::transform(std::forward<Function>(f), std::forward<Args>(args)...);
232 | 	}
233 | };
234 | 
235 | template <>
236 | struct call_if<false> {
237 | 	template <typename Function, typename... Args>
238 | 	constexpr static void transform(Function&&, Args&&...) noexcept {
239 | 	}
240 | };
241 | 
242 | /** Flips the first two variables. */
243 | struct flip {
244 | 	template <typename Function, typename First, typename Second, typename... Args>
245 | 	constexpr static auto transform(Function&& f, First&& first, Second&& second, Args&&... rest) {
246 | 		return std::forward<Function>(f)(std::forward<Second>(second),
247 | 		                                 std::forward<First>(first),
248 | 		                                 std::forward<Args>(rest)...);
249 | 	}
250 | };
251 | 
252 | /** Left cyclic shifts the parameters \a n places. */
253 | template <unsigned N>
254 | struct left_shift {
255 | 	template <typename Function, typename First, typename... Args>
256 | 	constexpr static auto transform(Function&& f, First&& first, Args&&... rest) {
257 | 		static_assert(N < 1 + sizeof...(rest),
258 | 		  "Cannot left shift more than the size of the parameter pack");
259 | 		return left_shift<N - 1>::transform(std::forward<Function>(f),
260 | 		                                    std::forward<Args>(rest)...,
261 | 		                                    std::forward<First>(first));
262 | 	}
263 | };
264 | 
265 | template <>
266 | struct left_shift<0u> {
267 | 	template <typename Function, typename... Args>
268 | 	constexpr static auto transform(Function&& f, Args&&... rest) {
269 | 		return id::transform(std::forward<Function>(f), std::forward<Args>(rest)...);
270 | 	}
271 | };
272 | 
273 | /** Right cyclic shifts the parameters \a n places. */
274 | template <unsigned N>
275 | struct right_shift {
276 | 	template <typename Function, typename... Args>
277 | 	constexpr static auto transform(Function&& f, Args&&... args) {
278 | 		static_assert(N < sizeof...(args),
279 | 		  "Cannot right shift more than the size of the parameter pack");
280 | 		return left_shift<sizeof...(Args) - N>::transform(std::forward<Function>(f),
281 | 		                                                  std::forward<Args>(args)...);
282 | 	}
283 | };
284 | 
285 | template <>
286 | struct right_shift<0u> {
287 | 	template <typename Function, typename... Args>
288 | 	constexpr static auto transform(Function&& f, Args&&... rest) {
289 | 		return id::transform(std::forward<Function>(f), std::forward<Args>(rest)...);
290 | 	}
291 | };
292 | 
293 | template <int N, bool NotNegative = (N >= 0)>
294 | struct shift;
295 | 
296 | template <int N>
297 | struct shift<N, true> {
298 | 	template <typename Function, typename... Args>
299 | 	constexpr static auto transform(Function&& f, Args&&... args) {
300 | 		return left_shift<N>::transform(std::forward<Function>(f),
301 | 		                                std::forward<Args>(args)...);
302 | 	}
303 | };
304 | 
305 | template <int N>
306 | struct shift<N, false> {
307 | 	template <typename Function, typename... Args>
308 | 	constexpr static auto transform(Function&& f, Args&&... args) {
309 | 		return right_shift<-N>::transform(std::forward<Function>(f),
310 | 		                                  std::forward<Args>(args)...);
311 | 	}
312 | };
313 | 
314 | /** Left cyclic shifts the tail of the parameters \a n places. */
315 | template <unsigned N>
316 | struct left_shift_tail {
317 | 	template <typename Function, typename Fixed, typename First, typename... Args>
318 | 	constexpr static auto transform(Function&& f, Fixed&& fixed, First&& first, Args&&... rest) {
319 | 		static_assert(N < 1 + sizeof...(rest),
320 | 		  "Cannot left shift more than the size of the tail of the parameter pack");
321 | 		return left_shift_tail<N - 1>::transform(std::forward<Function>(f),
322 | 		                                         std::forward<Fixed>(fixed),
323 | 		                                         std::forward<Args>(rest)...,
324 | 		                                         std::forward<First>(first));
325 | 	}
326 | };
327 | 
328 | template <>
329 | struct left_shift_tail<0u> {
330 | 	template <typename Function, typename... Args>
331 | 	constexpr static auto transform(Function&& f, Args&&... rest) {
332 | 		return id::transform(std::forward<Function>(f), std::forward<Args>(rest)...);
333 | 	}
334 | };
335 | 
336 | /** Right cyclic shifts the tail of the parameters \a n places. */
337 | template <unsigned N>
338 | struct right_shift_tail {
339 | 	template <typename Function, typename... Args>
340 | 	constexpr static auto transform(Function&& f, Args&&... args) {
341 | 		static_assert(N < sizeof...(args) - 1,
342 | 		  "Cannot right shift more than the size of the tail of the parameter pack");
343 | 		return left_shift_tail<sizeof...(Args) - N - 1>::transform(std::forward<Function>(f),
344 | 		                                                           std::forward<Args>(args)...);
345 | 	}
346 | };
347 | 
348 | template <>
349 | struct right_shift_tail<0u> {
350 | 	template <typename Function, typename... Args>
351 | 	constexpr static auto transform(Function&& f, Args&&... rest) {
352 | 		return id::transform(std::forward<Function>(f), std::forward<Args>(rest)...);
353 | 	}
354 | };
355 | 
356 | template <int N, bool NotNegative = (N >= 0)>
357 | struct shift_tail;
358 | 
359 | template <int N>
360 | struct shift_tail<N, true> {
361 | 	template <typename Function, typename... Args>
362 | 	constexpr static auto transform(Function&& f, Args&&... args) {
363 | 		return left_shift_tail<N>::transform(std::forward<Function>(f),
364 | 		                                     std::forward<Args>(args)...);
365 | 	}
366 | };
367 | 
368 | template <int N>
369 | struct shift_tail<N, false> {
370 | 	template <typename Function, typename... Args>
371 | 	constexpr static auto transform(Function&& f, Args&&... args) {
372 | 		return right_shift_tail<-N>::transform(std::forward<Function>(f),
373 | 		                                       std::forward<Args>(args)...);
374 | 	}
375 | };
376 | 
377 | namespace detail {
378 | 
379 | template <unsigned N>
380 | struct drop_helper {
381 | 	template <typename Function, typename First, typename... Args>
382 | 	constexpr static auto transform(Function&& f, First&&, Args&&... args) {
383 | 		return drop_helper<N - 1>::transform(std::forward<Function>(f), std::forward<Args>(args)...);
384 | 	}
385 | };
386 | 
387 | template <>
388 | struct drop_helper<0u> {
389 | 	template <typename Function, typename... Args>
390 | 	constexpr static auto transform(Function&& f, Args&&... args) {
391 | 		return id::transform(std::forward<Function>(f), std::forward<Args>(args)...);
392 | 	}
393 | };
394 | 
395 | }
396 | 
397 | /** Drops the first N arguments. */
398 | template <int N>
399 | struct drop {
400 | 	template <typename Function, typename... Args>
401 | 	constexpr static auto transform(Function&& f, Args&&... args) {
402 | 		static_assert(-count(args...) <= N && N <= count(args...),
403 | 		  "Cannot drop more variables than are passed");
404 | 		return detail::drop_helper<N < 0 ? N + count(args...) : N>::transform(std::forward<Function>(f), std::forward<Args>(args)...);
405 | 	}
406 | };
407 | 
408 | namespace detail {
409 | 
410 | template <unsigned N, bool ForwardAll>
411 | struct take_helper;
412 | 
413 | template <unsigned N>
414 | struct take_helper<N, true> {
415 | 	template <typename Function, typename... Args>
416 | 	constexpr static auto transform(Function&& f, Args&&... args) {
417 | 		return id::transform(std::forward<Function>(f), std::forward<Args>(args)...);
418 | 	}
419 | };
420 | 
421 | template <unsigned N>
422 | struct take_helper<N, false> {
423 | 	template <typename Function, typename... Args>
424 | 	constexpr static auto transform(Function&& f, Args&&... args) {
425 | 		return compose<left_shift<N>,
426 | 		               drop<sizeof...(args) - N>
427 | 		              >::transform(std::forward<Function>(f), std::forward<Args>(args)...);
428 | 	}
429 | };
430 | 
431 | }
432 | 
433 | /** Passes only the first N arguments. */
434 | template <int N>
435 | struct take {
436 | 	template <typename Function, typename... Args>
437 | 	constexpr static auto transform(Function&& f, Args&&... args) {
438 | 		static_assert(-count(args...) <= N && N <= count(args...), "Cannot take more parameters that are available");
439 | 		return detail::take_helper<N < 0 ? N + count(args...) : N,
440 | 		                           N == sizeof...(args)>::transform(std::forward<Function>(f),
441 | 		                                                            std::forward<Args>(args)...);
442 | 	}
443 | };
444 | 
445 | template <>
446 | struct take<0u> {
447 | 	template <typename Function, typename... Args>
448 | 	constexpr static auto transform(Function&& f, Args&&...) {
449 | 		return std::forward<Function>(f)();
450 | 	}
451 | };
452 | 
453 | /** Take only the arguments at positions N, N + 1, ..., M - 1, M */
454 | template <int N, int M>
455 | struct slice {
456 | 	template <typename Function, typename... Args>
457 | 	constexpr static auto transform(Function&& f, Args&&... args) {
458 | 		static_assert(-count(args...) <= N && N < count(args...),
459 | 		  "N is out of bounds");
460 | 		static_assert(-count(args...) <= M && M < count(args...),
461 | 		  "M is out of bounds");
462 | 		static int const A = (N + count(args...)) % count(args...);
463 | 		static int const B = (M + count(args...)) % count(args...);
464 | 		static_assert(A <= B, "N must be <= M");
465 | 		static_assert(B <= count(args...), "M is out of bounds");
466 | 		return m_slice<A, B>::transform(std::forward<Function>(f), std::forward<Args>(args)...);
467 | 	}
468 | 
469 | private:
470 | 	template <unsigned A, unsigned B>
471 | 	struct m_slice {
472 | 		template <typename Function, typename... Args>
473 | 		constexpr static auto transform(Function&& f, Args&&... args) {
474 | 			return compose<left_shift<A>,
475 | 			               drop<sizeof...(args) - (B - A)>
476 | 			              >::transform(std::forward<Function>(f), std::forward<Args>(args)...);
477 | 		}
478 | 	};
479 | };
480 | 
481 | /** Swap the parameters in the positions \a n and \a m. If a number is negative, it is counted from
482 |     the end of the parameter pack. e.g. -1 would be the last parameter. */
483 | template <int N, int M>
484 | struct swap {
485 | 	template <typename Function, typename... Args>
486 | 	constexpr static auto transform(Function&& f, Args&&... args) {
487 | 		static int const size = count(args...);
488 | 		static_assert(-size <= N && N < size,
489 | 		  "N is out of bounds");
490 | 		static_assert(-size <= M && M < size,
491 | 		  "M is out of bounds");
492 | 		static int const A = (N + size) % size;
493 | 		static int const B = (M + size) % size;
494 | 		static int const min = A < B ? A : B;
495 | 		static int const max = A < B ? B : A;
496 | 		return swap_helper<min, max>::transform(std::forward<Function>(f), std::forward<Args>(args)...);
497 | 	}
498 | 
499 | private:
500 | 	template <int Min, int Max>
501 | 	struct swap_helper {
502 | 		template <typename Function, typename... Args>
503 | 		constexpr static auto transform(Function&& f, Args&&... args) {
504 | 			return compose<shift<Min>,
505 | 			               shift_tail<Max - Min - 1>,
506 | 			               flip,
507 | 			               shift_tail<-(Max - Min - 1)>,
508 | 			               shift<-Min>
509 | 			              >::transform(std::forward<Function>(f), std::forward<Args>(args)...);
510 | 		}
511 | 	};
512 | 
513 | 	template <int MinMax>
514 | 	struct swap_helper<MinMax, MinMax> {
515 | 		template <typename Function, typename... Args>
516 | 		constexpr static auto transform(Function&& f, Args&&... args) {
517 | 			return id::transform(std::forward<Function>(f), std::forward<Args>(args)...);
518 | 		}
519 | 	};
520 | };
521 | 
522 | namespace detail {
523 | 
524 | template <int N, int Modulus>
525 | struct modulus {
526 | 	static int const value = (N + Modulus) % Modulus;
527 | };
528 | 
529 | }
530 | 
531 | template <int... Positions>
532 | struct cycle;
533 | 
534 | template <>
535 | struct cycle<> {
536 | 	template <typename Function, typename... Args>
537 | 	constexpr static auto transform(Function&& f, Args&&... args) {
538 | 		return id::transform(std::forward<Function>(f), std::forward<Args>(args)...);
539 | 	}
540 | };
541 | 
542 | template <int First>
543 | struct cycle<First> {
544 | 	template <typename Function, typename... Args>
545 | 	constexpr static auto transform(Function&& f, Args&&... args) {
546 | 		return id::transform(std::forward<Function>(f), std::forward<Args>(args)...);
547 | 	}
548 | };
549 | 
550 | template <int First, int Second, int... Rest>
551 | struct cycle<First, Second, Rest...> {
552 | 	template <typename Function, typename... Args>
553 | 	constexpr static auto transform(Function&& f, Args&&... args) {
554 | 		static_assert(vta::are_unique_ints<detail::modulus<First, count(args...)>::value,
555 | 		                                   detail::modulus<Second, count(args...)>::value,
556 | 		                                   detail::modulus<Rest, count(args...)>::value...>::value,
557 | 		  "The positions to permute must be unique");
558 | 		return compose<swap<First, Second>, cycle<First, Rest...>>::transform(std::forward<Function>(f), std::forward<Args>(args)...);
559 | 	}
560 | };
561 | 
562 | namespace detail {
563 | 
564 | template <unsigned N>
565 | struct reverse_helper {
566 | 	template <typename Function>
567 | 	constexpr static auto transform(Function&&) {
568 | 	}
569 | 
570 | 	template <typename Function, typename Arg>
571 | 	constexpr static auto transform(Function&& f, Arg&& arg) {
572 | 		return id::transform(std::forward<Function>(f), std::forward<Arg>(arg));
573 | 	}
574 | 
575 | 	template <typename Function, typename First, typename... Args>
576 | 	constexpr static auto transform(Function&& f, First&& first, Args&&... args) {
577 | 		return compose<swap<N - 1, -N>,
578 | 		               reverse_helper<N - 1>
579 | 		              >::transform(std::forward<Function>(f),
580 | 		                           std::forward<First>(first),
581 | 		                           std::forward<Args>(args)...);
582 | 	}
583 | };
584 | 
585 | template <>
586 | struct reverse_helper<0u> {
587 | 	template <typename Function, typename... Args>
588 | 	constexpr static auto transform(Function&& f, Args&&... args) {
589 | 		return id::transform(std::forward<Function>(f), std::forward<Args>(args)...);
590 | 	}
591 | };
592 | 
593 | }
594 | 
595 | /** Reverse the order of arguments */
596 | struct reverse {
597 | template <typename Function, typename... Args>
598 | 	constexpr static auto transform(Function&& f, Args&&... args) {
599 | 		return detail::reverse_helper<sizeof...(args) / 2>::transform(std::forward<Function>(f),
600 | 		                                                              std::forward<Args>(args)...);
601 | 	}
602 | };
603 | 
604 | namespace detail {
605 | 
606 | template <template <class> class Predicate, typename... Passed>
607 | struct filter_helper;
608 | 
609 | template <template <class> class Predicate, bool BPassed, typename... Passed>
610 | struct next_has_passed;
611 | 
612 | template <template <class> class Predicate, typename... Passed>
613 | struct next_has_passed<Predicate, true, Passed...> {
614 | 	template <typename Function, typename Next, typename... ToBeEvaluated>
615 | 	constexpr static auto transform(Function&& f, Passed&&... passed, Next&& next, ToBeEvaluated&&... rest) {
616 | 		return filter_helper<Predicate, Passed..., Next>::transform(std::forward<Function>(f),
617 | 		                                                            std::forward<Passed>(passed)...,
618 | 		                                                            std::forward<Next>(next),
619 | 		                                                            std::forward<ToBeEvaluated>(rest)...);
620 | 	}
621 | 
622 | 	template <typename Function>
623 | 	constexpr static auto transform(Function&& f, Passed&&... passed) {
624 | 		return std::forward<Function>(f)(std::forward<Passed>(passed)...);
625 | 	}
626 | };
627 | 
628 | template <template <class> class Predicate, typename... Passed>
629 | struct next_has_passed<Predicate, false, Passed...> {
630 | 	template <typename Function, typename Next, typename... ToBeEvaluated>
631 | 	constexpr static auto transform(Function&& f, Passed&&... passed, Next&&, ToBeEvaluated&&... rest) {
632 | 		return filter_helper<Predicate, Passed...>::transform(std::forward<Function>(f),
633 | 		                                                      std::forward<Passed>(passed)...,
634 | 		                                                      std::forward<ToBeEvaluated>(rest)...);
635 | 	}
636 | 
637 | 	template <typename Function>
638 | 	constexpr static auto transform(Function&& f, Passed&&... passed) {
639 | 		return std::forward<Function>(f)(std::forward<Passed>(passed)...);
640 | 	}
641 | };
642 | 
643 | template <template <class> class Predicate, typename... Passed>
644 | struct filter_helper {
645 | 	template <typename Function, typename Next, typename... ToBeEvaluated>
646 | 	constexpr static auto transform(Function&& f, Passed&&... passed, Next&& next, ToBeEvaluated&&... rest) {
647 | 		typedef next_has_passed<Predicate,
648 | 		                        Predicate<Next>::value,
649 | 		                        Passed...> NextTransform;
650 | 		return NextTransform::transform(std::forward<Function>(f),
651 | 		                                std::forward<Passed>(passed)...,
652 | 		                                std::forward<Next>(next),
653 | 		                                std::forward<ToBeEvaluated>(rest)...);
654 | 	}
655 | 
656 | 	template <typename Function, typename... ToBeEvaluated>
657 | 	constexpr static auto transform(Function&& f, Passed&&... passed) {
658 | 		return std::forward<Function>(f)(std::forward<Passed>(passed)...);
659 | 	}
660 | };
661 | 
662 | }
663 | 
664 | /** Filter in parameters only if Predicate<Arg>::value is true for each argument type. */
665 | template <template <class> class Predicate>
666 | struct filter {
667 | 	template <typename Function, typename... Args>
668 | 	constexpr static auto transform(Function&& f, Args&&... args) {
669 | 		typedef detail::filter_helper<Predicate> Next;
670 | 		return Next::transform(std::forward<Function>(f),
671 | 		                       std::forward<Args>(args)...);
672 | 	}
673 | };
674 | 
675 | /**************************************************************************************************
676 |  * Functions                                                                                      *
677 |  **************************************************************************************************/
678 | 
679 | template <typename Function>
680 | class map_f {
681 | 	Function mF;
682 | 
683 | public:
684 | 	constexpr map_f(Function f)
685 | 	: mF(std::move(f)) {
686 | 	}
687 | 
688 | 	template <typename First, typename... Args>
689 | 	constexpr void operator()(First&& first, Args&&... args) const {
690 | 		mF(std::forward<First>(first));
691 | 		operator()(std::forward<Args>(args)...);
692 | 	}
693 | 
694 | 	template <typename First, typename... Args>
695 | 	void operator()(First&& first, Args&&... args) {
696 | 		mF(std::forward<First>(first));
697 | 		operator()(std::forward<Args>(args)...);
698 | 	}
699 | 
700 | 	constexpr void operator()() const {
701 | 	}
702 | };
703 | 
704 | template <typename Function>
705 | constexpr map_f<typename std::remove_reference<Function>::type> map(Function&& f) {
706 | 	return {std::forward<Function>(f)};
707 | }
708 | 
709 | template <unsigned N, typename Function>
710 | class adjacent_map_f {
711 | 	Function mF;
712 | 
713 | public:
714 | 	constexpr adjacent_map_f(Function f)
715 | 	: mF(std::move(f)) {
716 | 	}
717 | 
718 | 	template <typename First, typename... Args>
719 | 	void operator()(First&& first, Args&&... args) const {
720 | 		take<N>::transform(mF, std::forward<First>(first), args...);
721 | 		call_if<(sizeof...(args) >= N)>::transform(*this, std::forward<Args>(args)...);
722 | 	}
723 | 
724 | 	template <typename First, typename... Args>
725 | 	void operator()(First&& first, Args&&... args) {
726 | 		take<N>::transform(mF, std::forward<First>(first), args...);
727 | 		call_if<(sizeof...(args) >= N)>::transform(*this, std::forward<Args>(args)...);
728 | 	}
729 | };
730 | 
731 | template <unsigned N, typename Function>
732 | constexpr adjacent_map_f<N, typename std::remove_reference<Function>::type> adjacent_map(Function&& f) {
733 | 	return {std::forward<Function>(f)};
734 | }
735 | 
736 | template <typename Function>
737 | class foldl_f {
738 | 	Function mF;
739 | 
740 | public:
741 | 	constexpr foldl_f(Function f)
742 | 	: mF(std::move(f)) {
743 | 	}
744 | 
745 | 	template <typename First, typename Second, typename... Args>
746 | 	constexpr auto operator()(First&& first, Second&& second, Args&&... args) const {
747 | 		return (*this)(mF(std::forward<First>(first), std::forward<Second>(second)),
748 | 		                  std::forward<Args>(args)...);
749 | 	}
750 | 
751 | 	template <typename First, typename Second, typename... Args>
752 | 	auto operator()(First&& first, Second&& second, Args&&... args) {
753 | 		return (*this)(mF(std::forward<First>(first), std::forward<Second>(second)),
754 | 		                  std::forward<Args>(args)...);
755 | 	}
756 | 
757 | private:
758 | 	template <typename Arg>
759 | 	constexpr Arg operator()(Arg&& arg) const {
760 | 		return std::forward<Arg>(arg);
761 | 	}
762 | };
763 | 
764 | template <typename Function>
765 | constexpr foldl_f<typename std::remove_reference<Function>::type> foldl(Function&& f) {
766 | 	return {std::forward<Function>(f)};
767 | }
768 | 
769 | template <typename Function>
770 | class foldr_f {
771 | 	Function mF;
772 | 
773 | public:
774 | 	foldr_f(Function f)
775 | 	: mF(std::move(f)) {
776 | 	}
777 | 
778 | 	template <typename First, typename Second, typename... Args>
779 | 	constexpr auto operator()(First&& first, Second&& second, Args&&... args) const {
780 | 		return mF(std::forward<First>(first),
781 | 		          (*this)(std::forward<Second>(second), std::forward<Args>(args)...));
782 | 	}
783 | 
784 | 	template <typename First, typename Second, typename... Args>
785 | 	auto operator()(First&& first, Second&& second, Args&&... args) {
786 | 		return mF(std::forward<First>(first),
787 | 		          (*this)(std::forward<Second>(second), std::forward<Args>(args)...));
788 | 	}
789 | 
790 | 	template <typename Arg>
791 | 	constexpr Arg operator()(Arg&& arg) const noexcept {
792 | 		return std::forward<Arg>(arg);
793 | 	}
794 | };
795 | 
796 | template <typename Function>
797 | constexpr foldr_f<typename std::remove_reference<Function>::type> foldr(Function&& f) {
798 | 	return {std::forward<Function>(f)};
799 | }
800 | 
801 | template <typename Function>
802 | class all_of_f {
803 | 	Function mF;
804 | 
805 | public:
806 | 	constexpr all_of_f(Function f)
807 | 	: mF(std::move(f)) {
808 | 	}
809 | 
810 | 	template <typename First, typename... Args>
811 | 	constexpr bool operator()(First&& first, Args&&... args) const {
812 | 		return mF(std::forward<First>(first)) ? operator()(std::forward<Args>(args)...) : false;
813 | 	}
814 | 
815 | 	template <typename First, typename... Args>
816 | 	bool operator()(First&& first, Args&&... args) {
817 | 		return mF(std::forward<First>(first)) ? operator()(std::forward<Args>(args)...) : false;
818 | 	}
819 | 
820 | 	constexpr bool operator()() const {
821 | 		return true;
822 | 	}
823 | };
824 | 
825 | template <typename Function>
826 | constexpr all_of_f<typename std::remove_reference<Function>::type> all_of(Function&& f) {
827 | 	return {std::forward<Function>(f)};
828 | }
829 | 
830 | template <typename Function>
831 | class any_of_f {
832 | 	Function mF;
833 | 
834 | public:
835 | 	constexpr any_of_f(Function f)
836 | 	: mF(std::move(f)) {
837 | 	}
838 | 
839 | 	template <typename First, typename... Args>
840 | 	constexpr bool operator()(First&& first, Args&&... args) const {
841 | 		return mF(std::forward<First>(first)) ? true : operator()(std::forward<Args>(args)...);
842 | 	}
843 | 
844 | 	template <typename First, typename... Args>
845 | 	bool operator()(First&& first, Args&&... args) {
846 | 		return mF(std::forward<First>(first)) ? true : operator()(std::forward<Args>(args)...);
847 | 	}
848 | 
849 | 	constexpr bool operator()() const {
850 | 		return false;
851 | 	}
852 | };
853 | 
854 | template <typename Function>
855 | constexpr any_of_f<typename std::remove_reference<Function>::type> any_of(Function&& f) {
856 | 	return {std::forward<Function>(f)};
857 | }
858 | 
859 | template <typename Function>
860 | class none_of_f {
861 | 	Function mF;
862 | 
863 | public:
864 | 	constexpr none_of_f(Function f)
865 | 	: mF(std::move(f)) {
866 | 	}
867 | 
868 | 	template <typename First, typename... Args>
869 | 	constexpr bool operator()(First&& first, Args&&... args) const {
870 | 		return mF(std::forward<First>(first)) ? false : operator()(std::forward<Args>(args)...);
871 | 	}
872 | 
873 | 	template <typename First, typename... Args>
874 | 	bool operator()(First&& first, Args&&... args) {
875 | 		return mF(std::forward<First>(first)) ? false : operator()(std::forward<Args>(args)...);
876 | 	}
877 | 
878 | 	constexpr bool operator()() const noexcept {
879 | 		return true;
880 | 	}
881 | };
882 | 
883 | template <typename Function>
884 | constexpr none_of_f<typename std::remove_reference<Function>::type> none_of(Function&& f) {
885 | 	return {std::forward<Function>(f)};
886 | }
887 | 
888 | /**************************************************************************************************
889 |  * Utility Functions                                                                              *
890 |  **************************************************************************************************/
891 | 
892 | template <typename T>
893 | constexpr T const& add_const(T&& t) noexcept {
894 | 	return t;
895 | }
896 | 
897 | template <typename Arg, typename... Args>
898 | constexpr auto head(Arg&& head, Args&&...) noexcept {
899 | 	return std::forward<Arg>(head);
900 | }
901 | 
902 | template <typename Arg>
903 | constexpr auto last(Arg&& arg) noexcept {
904 | 	return std::forward<Arg>(arg);
905 | }
906 | 
907 | template <typename Arg1, typename... Args>
908 | constexpr auto last(Arg1&&, Args&&... rest) noexcept {
909 | 	return last(std::forward<Args>(rest)...);
910 | }
911 | 
912 | namespace detail {
913 | 
914 | template <unsigned N>
915 | struct at_helper;
916 | 
917 | template <unsigned N>
918 | struct at_helper {
919 | 	template <typename Arg, typename... Args>
920 | 	constexpr static auto get(Arg&&, Args&&... args) noexcept {
921 | 		return at_helper<N - 1>::get(std::forward<Args>(args)...);
922 | 	}
923 | };
924 | 
925 | template <>
926 | struct at_helper<0u> {
927 | 	template <typename... Args>
928 | 	constexpr static auto get(Args&&... args) noexcept {
929 | 		return head(std::forward<Args>(args)...);
930 | 	}
931 | };
932 | 
933 | }
934 | 
935 | template <int N, typename... Args>
936 | constexpr auto at(Args&&... args) noexcept {
937 | 	static_assert(-count(args...) <= N && N < count(args...), "N is out of bounds");
938 | 	return detail::at_helper<(N + count(args...)) % count(args...)>::get(std::forward<Args>(args)...);
939 | }
940 | 
941 | /**************************************************************************************************
942 |  * Type Aliases                                                                                   *
943 |  **************************************************************************************************/
944 | 
945 | template <typename... Args>
946 | using head_t = decltype(head(std::declval<Args>()...));
947 | 
948 | template <typename... Args>
949 | using last_t = decltype(last(std::declval<Args>()...));
950 | 
951 | template <int N>
952 | struct at_t {
953 | 	template <typename... Args>
954 | 	using type = decltype(at<N>(std::declval<Args>()...));
955 | };
956 | 
957 | }
958 | 
959 | #endif
960 | 


--------------------------------------------------------------------------------
/tests/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | cmake_minimum_required(VERSION 2.6)
 2 | 
 3 | if(CMAKE_COMPILER_IS_GNUCC)
 4 |   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -pedantic -Wextra -Werror -std=c++1y")
 5 | endif()
 6 | 
 7 | if(MINGW)
 8 |   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mwindows")
 9 | endif()
10 | 
11 | find_package(Boost 1.55.0 REQUIRED COMPONENTS unit_test_framework)
12 | 
13 | if(WIN32)
14 | 	set(Boost_USE_STATIC_LIBS        ON)
15 | 	set(Boost_USE_MULTITHREADED      ON)
16 | 	set(Boost_USE_STATIC_RUNTIME    OFF)
17 | else()
18 | 	add_definitions(-DBOOST_TEST_DYN_LINK)
19 | endif()
20 | 
21 | include_directories(../include/)
22 | include_directories(${Boost_INCLUDE_DIRS})
23 | 
24 | set(SOURCES
25 | 	main.cpp
26 | 	algorithms.cpp
27 | )
28 | 
29 | add_executable(unit_tests ${SOURCES})
30 | target_link_libraries(unit_tests ${Boost_LIBRARIES})
31 | add_test(unit_tests unit_tests)
32 | 


--------------------------------------------------------------------------------
/tests/algorithms.cpp:
--------------------------------------------------------------------------------
  1 | #include "vta/algorithms.hpp"
  2 | 
  3 | #include <boost/test/unit_test.hpp>
  4 | 
  5 | #include <algorithm>
  6 | #include <iostream>
  7 | #include <type_traits>
  8 | #include <string>
  9 | 
 10 | namespace {
 11 | 
 12 | struct printer {
 13 | 	printer(std::ostream& str)
 14 | 	: m_str{&str} {
 15 | 	}
 16 | 
 17 | 	template <typename T>
 18 | 	void operator()(T const& obj) {
 19 | 		*m_str << obj;
 20 | 	}
 21 | 
 22 | 	std::ostream* m_str;
 23 | };
 24 | 
 25 | struct string_concat {
 26 | 	template <typename LHS, typename RHS>
 27 | 	std::string operator()(LHS const& lhs, RHS const& rhs) const {
 28 | 		std::stringstream ss;
 29 | 		ss << lhs << rhs;
 30 | 		return ss.str();
 31 | 	}
 32 | };
 33 | 
 34 | struct is_positive_int {
 35 | 	bool operator()(int x) const {
 36 | 		return x > 0;
 37 | 	}
 38 | 
 39 | 	template <typename T>
 40 | 	bool operator()(T const&) const {
 41 | 		return false;
 42 | 	}
 43 | };
 44 | 
 45 | bool is_true(bool p) {
 46 | 	return p;
 47 | }
 48 | 
 49 | struct adjacent_printer {
 50 | 	adjacent_printer(std::string& str)
 51 | 	: m_str{&str} {
 52 | 	}
 53 | 
 54 | 	void operator()(int i, int j) {
 55 | 		std::stringstream ss;
 56 | 		ss << i * j;
 57 | 		*m_str += ss.str();
 58 | 	}
 59 | 
 60 | 	std::string* m_str;
 61 | };
 62 | 
 63 | }
 64 | 
 65 | BOOST_AUTO_TEST_SUITE(algorithms)
 66 | 
 67 | BOOST_AUTO_TEST_CASE(are_same) {
 68 | 	static_assert(vta::are_same<>::value, "");
 69 | 	static_assert(vta::are_same<int>::value, "");
 70 | 	static_assert(vta::are_same<int, int>::value, "");
 71 | 	static_assert(vta::are_same<int, int, int>::value, "");
 72 | 	static_assert(!vta::are_same<int, float>::value, "");
 73 | 	static_assert(!vta::are_same<int&, int>::value, "");
 74 | 	static_assert(!vta::are_same<int const&, int&>::value, "");
 75 | 	static_assert(!vta::are_same<int&&, int&>::value, "");
 76 | 	static_assert(!vta::are_same<const int, int>::value, "");
 77 | 	static_assert(!vta::are_same<volatile int, int>::value, "");
 78 | }
 79 | 
 80 | BOOST_AUTO_TEST_CASE(are_same_after) {
 81 | 	static_assert(vta::are_same_after<std::remove_reference>::value, "");
 82 | 	static_assert(vta::are_same_after<std::remove_reference, int>::value, "");
 83 | 	static_assert(vta::are_same_after<std::remove_reference, int&&, int&>::value, "");
 84 | 	static_assert(!vta::are_same_after<std::remove_reference, int, float>::value, "");
 85 | }
 86 | 
 87 | BOOST_AUTO_TEST_CASE(are_unique_ints) {
 88 | 	static_assert(vta::are_unique_ints<>::value, "");
 89 | 	static_assert(vta::are_unique_ints<1>::value, "");
 90 | 	static_assert(vta::are_unique_ints<1, 2>::value, "");
 91 | 	static_assert(!vta::are_unique_ints<1, 1>::value, "");
 92 | 	static_assert(vta::are_unique_ints<1, -1>::value, "");
 93 | 	static_assert(vta::are_unique_ints<1, 2, 3, 4, 5>::value, "");
 94 | 	static_assert(!vta::are_unique_ints<1, 2, 3, 1, 5>::value, "");
 95 | 	static_assert(!vta::are_unique_ints<2, 3, 4, 5, 6, 5>::value, "");
 96 | }
 97 | 
 98 | BOOST_AUTO_TEST_CASE(are_unique) {
 99 | 	static_assert(vta::are_unique<>::value, "");
100 | 	static_assert(vta::are_unique<int>::value, "");
101 | 	static_assert(vta::are_unique<int, float>::value, "");
102 | 	static_assert(!vta::are_unique<int, int>::value, "");
103 | 	static_assert(vta::are_unique<int, int&>::value, "");
104 | 	static_assert(vta::are_unique<int&&, int&>::value, "");
105 | 	static_assert(vta::are_unique<int, float>::value, "");
106 | 	static_assert(!vta::are_unique<int, float, int>::value, "");
107 | 	static_assert(vta::are_unique<int, float, char>::value, "");
108 | }
109 | 
110 | BOOST_AUTO_TEST_CASE(are_unique_after) {
111 | 	static_assert(vta::are_unique_after<std::remove_reference>::value, "");
112 | 	static_assert(vta::are_unique_after<std::remove_reference, int>::value, "");
113 | 	static_assert(!vta::are_unique_after<std::remove_reference, int&&, int&>::value, "");
114 | 	static_assert(vta::are_unique_after<std::remove_reference, int, float>::value, "");
115 | }
116 | 
117 | BOOST_AUTO_TEST_CASE(head) {
118 | 	BOOST_CHECK_EQUAL(vta::head(0), 0);
119 | 	BOOST_CHECK_EQUAL(vta::head(std::string{"1"}), "1");
120 | 	BOOST_CHECK_EQUAL(vta::head(0, 1, 2), 0);
121 | 	BOOST_CHECK_EQUAL(vta::head(1, "2", 3), 1);
122 | }
123 | 
124 | BOOST_AUTO_TEST_CASE(last) {
125 | 	BOOST_CHECK_EQUAL(vta::last(0), 0);
126 | 	BOOST_CHECK_EQUAL(vta::last(std::string{"1"}), "1");
127 | 	BOOST_CHECK_EQUAL(vta::last(0, 1), 1);
128 | 	BOOST_CHECK_EQUAL(vta::last(0, 1, 2), 2);
129 | 	BOOST_CHECK_EQUAL(vta::last(1, "2", 3), 3);
130 | }
131 | 
132 | BOOST_AUTO_TEST_CASE(at) {
133 | 	BOOST_CHECK_EQUAL(vta::at<0>(0), 0);
134 | 	BOOST_CHECK_EQUAL(vta::at<-1>(0), 0);
135 | 	BOOST_CHECK_EQUAL(vta::at<0>(1, '2', 3u, 4.5, "six"), 1);
136 | 	BOOST_CHECK_EQUAL(vta::at<-5>(1, '2', 3u, 4.5, "six"), 1);
137 | 	BOOST_CHECK_EQUAL(vta::at<3>(1, '2', 3u, 4.5, "six"), 4.5);
138 | 	BOOST_CHECK_EQUAL(vta::at<-2>(1, '2', 3u, 4.5, "six"), 4.5);
139 | 	BOOST_CHECK_EQUAL(vta::at<4>(1, '2', 3u, 4.5, "six"), std::string{"six"});
140 | 	BOOST_CHECK_EQUAL(vta::at<-1>(1, '2', 3u, 4.5, "six"), std::string{"six"});
141 | }
142 | 
143 | BOOST_AUTO_TEST_CASE(head_t) {
144 | 	static_assert(std::is_same<int, vta::head_t<int>>::value, "");
145 | 	static_assert(std::is_same<int, vta::head_t<int, char>>::value, "");
146 | 	static_assert(std::is_same<float, vta::head_t<float, char>>::value, "");
147 | 	static_assert(!std::is_same<float, vta::head_t<int, char>>::value, "");
148 | }
149 | 
150 | BOOST_AUTO_TEST_CASE(last_t) {
151 | 	static_assert(std::is_same<int, vta::last_t<int>>::value, "");
152 | 	static_assert(std::is_same<char, vta::last_t<int, char>>::value, "");
153 | 	static_assert(std::is_same<char, vta::last_t<float, char>>::value, "");
154 | 	static_assert(!std::is_same<int, vta::last_t<int, char>>::value, "");
155 | }
156 | 
157 | BOOST_AUTO_TEST_CASE(at_t) {
158 | 	static_assert(std::is_same<int, vta::at_t<0>::type<int>>::value, "");
159 | 	static_assert(std::is_same<int, vta::at_t<0>::type<int, char>>::value, "");
160 | 	static_assert(std::is_same<char, vta::at_t<1>::type<int, char>>::value, "");
161 | 	static_assert(std::is_same<char, vta::at_t<-1>::type<int, char>>::value, "");
162 | 	static_assert(std::is_same<int, vta::at_t<2>::type<float, char, int>>::value, "");
163 | 	static_assert(!std::is_same<int, vta::at_t<-2>::type<float, char, int>>::value, "");
164 | }
165 | 
166 | /**************************************************************************************************
167 |  * Transformations                                                                                *
168 |  **************************************************************************************************/
169 | 
170 | BOOST_AUTO_TEST_CASE(flip) {
171 | 	{
172 | 		std::stringstream ss;
173 | 		vta::forward_after<vta::flip>(vta::map(printer{ss}))(1, '2', 3u, 4.5, "six");
174 | 		BOOST_CHECK_EQUAL(ss.str(), "2134.5six");
175 | 	}
176 | }
177 | 
178 | BOOST_AUTO_TEST_CASE(left_shift) {
179 | 	{
180 | 		std::stringstream ss;
181 | 		vta::forward_after<vta::left_shift<0>>(vta::map(printer{ss}))();
182 | 		BOOST_CHECK_EQUAL(ss.str(), "");
183 | 	}
184 | 
185 | 	{
186 | 		std::stringstream ss;
187 | 		vta::forward_after<vta::left_shift<0>>(vta::map(printer{ss}))(1, '2', 3u, 4.5, "six");
188 | 		BOOST_CHECK_EQUAL(ss.str(), "1234.5six");
189 | 	}
190 | 
191 | 	{
192 | 		std::stringstream ss;
193 | 		vta::forward_after<vta::left_shift<1>>(vta::map(printer{ss}))(1, '2', 3u, 4.5, "six");
194 | 		BOOST_CHECK_EQUAL(ss.str(), "234.5six1");
195 | 	}
196 | 
197 | 	{
198 | 		std::stringstream ss;
199 | 		vta::forward_after<vta::left_shift<4>>(vta::map(printer{ss}))(1, '2', 3u, 4.5, "six");
200 | 		BOOST_CHECK_EQUAL(ss.str(), "six1234.5");
201 | 	}
202 | }
203 | 
204 | BOOST_AUTO_TEST_CASE(right_shift) {
205 | 	{
206 | 		std::stringstream ss;
207 | 		vta::forward_after<vta::right_shift<0>>(vta::map(printer{ss}))();
208 | 		BOOST_CHECK_EQUAL(ss.str(), "");
209 | 	}
210 | 
211 | 	{
212 | 		std::stringstream ss;
213 | 		vta::forward_after<vta::right_shift<0>>(vta::map(printer{ss}))(1, '2', 3u, 4.5, "six");
214 | 		BOOST_CHECK_EQUAL(ss.str(), "1234.5six");
215 | 	}
216 | 
217 | 	{
218 | 		std::stringstream ss;
219 | 		vta::forward_after<vta::right_shift<1>>(vta::map(printer{ss}))(1, '2', 3u, 4.5, "six");
220 | 		BOOST_CHECK_EQUAL(ss.str(), "six1234.5");
221 | 	}
222 | 
223 | 	{
224 | 		std::stringstream ss;
225 | 		vta::forward_after<vta::right_shift<4>>(vta::map(printer{ss}))(1, '2', 3u, 4.5, "six");
226 | 		BOOST_CHECK_EQUAL(ss.str(), "234.5six1");
227 | 	}
228 | }
229 | 
230 | BOOST_AUTO_TEST_CASE(shift) {
231 | 	{
232 | 		std::stringstream ss;
233 | 		vta::forward_after<vta::shift<0>>(vta::map(printer{ss}))();
234 | 		BOOST_CHECK_EQUAL(ss.str(), "");
235 | 	}
236 | 
237 | 	{
238 | 		std::stringstream ss;
239 | 		vta::forward_after<vta::shift<0>>(vta::map(printer{ss}))(1, '2', 3u, 4.5, "six");
240 | 		BOOST_CHECK_EQUAL(ss.str(), "1234.5six");
241 | 	}
242 | 
243 | 	{
244 | 		std::stringstream ss;
245 | 		vta::forward_after<vta::shift<1>>(vta::map(printer{ss}))(1, '2', 3u, 4.5, "six");
246 | 		BOOST_CHECK_EQUAL(ss.str(), "234.5six1");
247 | 	}
248 | 
249 | 	{
250 | 		std::stringstream ss;
251 | 		vta::forward_after<vta::shift<-2>>(vta::map(printer{ss}))(1, '2', 3u, 4.5, "six");
252 | 		BOOST_CHECK_EQUAL(ss.str(), "4.5six123");
253 | 	}
254 | }
255 | 
256 | BOOST_AUTO_TEST_CASE(left_shift_tail) {
257 | 	{
258 | 		std::stringstream ss;
259 | 		vta::forward_after<vta::left_shift_tail<0>>(vta::map(printer{ss}))();
260 | 		BOOST_CHECK_EQUAL(ss.str(), "");
261 | 	}
262 | 
263 | 	{
264 | 		std::stringstream ss;
265 | 		vta::forward_after<vta::left_shift_tail<0>>(vta::map(printer{ss}))(1, '2', 3u, 4.5, "six");
266 | 		BOOST_CHECK_EQUAL(ss.str(), "1234.5six");
267 | 	}
268 | 
269 | 	{
270 | 		std::stringstream ss;
271 | 		vta::forward_after<vta::left_shift_tail<1>>(vta::map(printer{ss}))(1, '2', 3u, 4.5, "six");
272 | 		BOOST_CHECK_EQUAL(ss.str(), "134.5six2");
273 | 	}
274 | 
275 | 	{
276 | 		std::stringstream ss;
277 | 		vta::forward_after<vta::left_shift_tail<2>>(vta::map(printer{ss}))(1, '2', 3u, 4.5, "six");
278 | 		BOOST_CHECK_EQUAL(ss.str(), "14.5six23");
279 | 	}
280 | }
281 | 
282 | BOOST_AUTO_TEST_CASE(right_shift_tail) {
283 | 	{
284 | 		std::stringstream ss;
285 | 		vta::forward_after<vta::right_shift_tail<0>>(vta::map(printer{ss}))();
286 | 		BOOST_CHECK_EQUAL(ss.str(), "");
287 | 	}
288 | 
289 | 	{
290 | 		std::stringstream ss;
291 | 		vta::forward_after<vta::right_shift_tail<0>>(vta::map(printer{ss}))(1, '2', 3u, 4.5, "six");
292 | 		BOOST_CHECK_EQUAL(ss.str(), "1234.5six");
293 | 	}
294 | 
295 | 	{
296 | 		std::stringstream ss;
297 | 		vta::forward_after<vta::right_shift_tail<1>>(vta::map(printer{ss}))(1, '2', 3u, 4.5, "six");
298 | 		BOOST_CHECK_EQUAL(ss.str(), "1six234.5");
299 | 	}
300 | 
301 | 	{
302 | 		std::stringstream ss;
303 | 		vta::forward_after<vta::right_shift_tail<2>>(vta::map(printer{ss}))(1, '2', 3u, 4.5, "six");
304 | 		BOOST_CHECK_EQUAL(ss.str(), "14.5six23");
305 | 	}
306 | }
307 | 
308 | BOOST_AUTO_TEST_CASE(shift_tail) {
309 | 	{
310 | 		std::stringstream ss;
311 | 		vta::forward_after<vta::shift_tail<0>>(vta::map(printer{ss}))();
312 | 		BOOST_CHECK_EQUAL(ss.str(), "");
313 | 	}
314 | 
315 | 	{
316 | 		std::stringstream ss;
317 | 		vta::forward_after<vta::shift_tail<0>>(vta::map(printer{ss}))(1, '2', 3u, 4.5, "six");
318 | 		BOOST_CHECK_EQUAL(ss.str(), "1234.5six");
319 | 	}
320 | 
321 | 	{
322 | 		std::stringstream ss;
323 | 		vta::forward_after<vta::shift_tail<1>>(vta::map(printer{ss}))(1, '2', 3u, 4.5, "six");
324 | 		BOOST_CHECK_EQUAL(ss.str(), "134.5six2");
325 | 	}
326 | 
327 | 	{
328 | 		std::stringstream ss;
329 | 		vta::forward_after<vta::shift_tail<-1>>(vta::map(printer{ss}))(1, '2', 3u, 4.5, "six");
330 | 		BOOST_CHECK_EQUAL(ss.str(), "1six234.5");
331 | 	}
332 | }
333 | 
334 | BOOST_AUTO_TEST_CASE(drop) {
335 | 	{
336 | 		BOOST_CHECK_EQUAL(vta::forward_after<vta::drop<0>>([](){ return 1; })(), 1);
337 | 	}
338 | 
339 | 	{
340 | 		std::stringstream ss;
341 | 		vta::forward_after<vta::drop<0>>(vta::map(printer{ss}))(1, '2', 3u, 4.5, "six");
342 | 		BOOST_CHECK_EQUAL(ss.str(), "1234.5six");
343 | 	}
344 | 
345 | 	{
346 | 		std::stringstream ss;
347 | 		vta::forward_after<vta::drop<1>>(vta::map(printer{ss}))(1, '2', 3u, 4.5, "six");
348 | 		BOOST_CHECK_EQUAL(ss.str(), "234.5six");
349 | 	}
350 | 
351 | 	{
352 | 		std::stringstream ss;
353 | 		vta::forward_after<vta::drop<2>>(vta::map(printer{ss}))(1, '2', 3u, 4.5, "six");
354 | 		BOOST_CHECK_EQUAL(ss.str(), "34.5six");
355 | 	}
356 | 
357 | 	{
358 | 		std::stringstream ss;
359 | 		vta::forward_after<vta::drop<5>>(vta::map(printer{ss}))(1, '2', 3u, 4.5, "six");
360 | 		BOOST_CHECK_EQUAL(ss.str(), "");
361 | 	}
362 | 
363 | 	{
364 | 		std::stringstream ss;
365 | 		vta::forward_after<vta::drop<-5>>(vta::map(printer{ss}))(1, '2', 3u, 4.5, "six");
366 | 		BOOST_CHECK_EQUAL(ss.str(), "1234.5six");
367 | 	}
368 | 
369 | 	{
370 | 		std::stringstream ss;
371 | 		vta::forward_after<vta::drop<-3>>(vta::map(printer{ss}))(1, '2', 3u, 4.5, "six");
372 | 		BOOST_CHECK_EQUAL(ss.str(), "34.5six");
373 | 	}
374 | 
375 | 	{
376 | 		std::stringstream ss;
377 | 		vta::forward_after<vta::drop<-1>>(vta::map(printer{ss}))(1, '2', 3u, 4.5, "six");
378 | 		BOOST_CHECK_EQUAL(ss.str(), "six");
379 | 	}
380 | }
381 | 
382 | BOOST_AUTO_TEST_CASE(take) {
383 | 	{
384 | 		std::stringstream ss;
385 | 		vta::forward_after<vta::take<0>>(vta::map(printer{ss}))(1, '2', 3u, 4.5, "six");
386 | 		BOOST_CHECK_EQUAL(ss.str(), "");
387 | 	}
388 | 
389 | 	{
390 | 		std::stringstream ss;
391 | 		vta::forward_after<vta::take<1>>(vta::map(printer{ss}))(1, '2', 3u, 4.5, "six");
392 | 		BOOST_CHECK_EQUAL(ss.str(), "1");
393 | 	}
394 | 
395 | 	{
396 | 		std::stringstream ss;
397 | 		vta::forward_after<vta::take<2>>(vta::map(printer{ss}))(1, '2', 3u, 4.5, "six");
398 | 		BOOST_CHECK_EQUAL(ss.str(), "12");
399 | 	}
400 | 
401 | 	{
402 | 		std::stringstream ss;
403 | 		vta::forward_after<vta::take<4>>(vta::map(printer{ss}))(1, '2', 3u, 4.5, "six");
404 | 		BOOST_CHECK_EQUAL(ss.str(), "1234.5");
405 | 	}
406 | 
407 | 	{
408 | 		std::stringstream ss;
409 | 		vta::forward_after<vta::take<-5>>(vta::map(printer{ss}))(1, '2', 3u, 4.5, "six");
410 | 		BOOST_CHECK_EQUAL(ss.str(), "");
411 | 	}
412 | 
413 | 	{
414 | 		std::stringstream ss;
415 | 		vta::forward_after<vta::take<-3>>(vta::map(printer{ss}))(1, '2', 3u, 4.5, "six");
416 | 		BOOST_CHECK_EQUAL(ss.str(), "12");
417 | 	}
418 | 
419 | 	{
420 | 		std::stringstream ss;
421 | 		vta::forward_after<vta::take<-1>>(vta::map(printer{ss}))(1, '2', 3u, 4.5, "six");
422 | 		BOOST_CHECK_EQUAL(ss.str(), "1234.5");
423 | 	}
424 | }
425 | 
426 | BOOST_AUTO_TEST_CASE(cycle) {
427 | 	{
428 | 		std::stringstream ss;
429 | 		vta::forward_after<vta::cycle<>>(vta::map(printer{ss}))(1, '2', 3u, 4.5, "six");
430 | 		BOOST_CHECK_EQUAL(ss.str(), "1234.5six");
431 | 	}
432 | 
433 | 	{
434 | 		std::stringstream ss;
435 | 		vta::forward_after<vta::cycle<0>>(vta::map(printer{ss}))(1, '2', 3u, 4.5, "six");
436 | 		BOOST_CHECK_EQUAL(ss.str(), "1234.5six");
437 | 	}
438 | 
439 | 	{
440 | 		std::stringstream ss;
441 | 		vta::forward_after<vta::cycle<-3>>(vta::map(printer{ss}))(1, '2', 3u, 4.5, "six");
442 | 		BOOST_CHECK_EQUAL(ss.str(), "1234.5six");
443 | 	}
444 | 
445 | 	{
446 | 		std::stringstream ss;
447 | 		vta::forward_after<vta::cycle<0, 1>>(vta::map(printer{ss}))(1, '2', 3u, 4.5, "six");
448 | 		BOOST_CHECK_EQUAL(ss.str(), "2134.5six");
449 | 	}
450 | 
451 | 	{
452 | 		std::stringstream ss;
453 | 		vta::forward_after<vta::cycle<0, 1, 2>>(vta::map(printer{ss}))(1, '2', 3u, 4.5, "six");
454 | 		BOOST_CHECK_EQUAL(ss.str(), "3124.5six");
455 | 	}
456 | 
457 | 	{
458 | 		std::stringstream ss;
459 | 		vta::forward_after<vta::cycle<-1, 0>>(vta::map(printer{ss}))(1, '2', 3u, 4.5, "six");
460 | 		BOOST_CHECK_EQUAL(ss.str(), "six234.51");
461 | 	}
462 | 
463 | 	{
464 | 		std::stringstream ss;
465 | 		vta::forward_after<vta::cycle<0, 2, 4>>(vta::map(printer{ss}))(1, '2', 3u, 4.5, "six");
466 | 		BOOST_CHECK_EQUAL(ss.str(), "six214.53");
467 | 	}
468 | 
469 | 	{
470 | 		std::stringstream ss;
471 | 		vta::forward_after<vta::cycle<4, 1, 2, 0>>(vta::map(printer{ss}))(1, '2', 3u, 4.5, "six");
472 | 		BOOST_CHECK_EQUAL(ss.str(), "3six24.51");
473 | 	}
474 | 
475 | 	{
476 | 		std::stringstream ss;
477 | 		vta::forward_after<vta::cycle<0, 4, 2, 3, 1>>(vta::map(printer{ss}))(1, '2', 3u, 4.5, "six");
478 | 		BOOST_CHECK_EQUAL(ss.str(), "24.5six31");
479 | 	}
480 | }
481 | 
482 | BOOST_AUTO_TEST_CASE(reverse) {
483 | 	{
484 | 		std::stringstream ss;
485 | 		vta::forward_after<vta::reverse>(vta::map(printer{ss}))();
486 | 		BOOST_CHECK_EQUAL(ss.str(), "");
487 | 	}
488 | 
489 | 	{
490 | 		std::stringstream ss;
491 | 		vta::forward_after<vta::reverse>(vta::map(printer{ss}))(1);
492 | 		BOOST_CHECK_EQUAL(ss.str(), "1");
493 | 	}
494 | 
495 | 	{
496 | 		std::stringstream ss;
497 | 		vta::forward_after<vta::reverse>(vta::map(printer{ss}))(1, '2');
498 | 		BOOST_CHECK_EQUAL(ss.str(), "21");
499 | 	}
500 | 
501 | 	{
502 | 		std::stringstream ss;
503 | 		vta::forward_after<vta::reverse>(vta::map(printer{ss}))(1, '2', 3u, 4.5, "six");
504 | 		BOOST_CHECK_EQUAL(ss.str(), "six4.5321");
505 | 	}
506 | }
507 | 
508 | BOOST_AUTO_TEST_CASE(filter) {
509 | 	{
510 | 		std::stringstream ss;
511 | 		vta::forward_after<vta::filter<std::is_integral>>(vta::map(printer{ss}))();
512 | 		BOOST_CHECK_EQUAL(ss.str(), "");
513 | 	}
514 | 
515 | 	{
516 | 		std::stringstream ss;
517 | 		vta::forward_after<vta::filter<std::is_integral>>(vta::map(printer{ss}))(1);
518 | 		BOOST_CHECK_EQUAL(ss.str(), "1");
519 | 	}
520 | 
521 | 	{
522 | 		std::stringstream ss;
523 | 		vta::forward_after<vta::filter<std::is_integral>>(vta::map(printer{ss}))("1");
524 | 		BOOST_CHECK_EQUAL(ss.str(), "");
525 | 	}
526 | 
527 | 	{
528 | 		std::stringstream ss;
529 | 		vta::forward_after<vta::filter<std::is_integral>>(vta::map(printer{ss}))(1, "2", 3.0);
530 | 		BOOST_CHECK_EQUAL(ss.str(), "1");
531 | 	}
532 | 
533 | 	{
534 | 		std::stringstream ss;
535 | 		vta::forward_after<vta::filter<std::is_integral>>(vta::map(printer{ss}))(1, '2', 3u, 4.5, "six");
536 | 		BOOST_CHECK_EQUAL(ss.str(), "123");
537 | 	}
538 | }
539 | 
540 | // Functions
541 | 
542 | BOOST_AUTO_TEST_CASE(map) {
543 | 	std::stringstream ss;
544 | 	vta::map(printer{ss})(1, 2, 3u, ' ', 4.5, " hello", " world!");
545 | 	BOOST_CHECK_EQUAL(ss.str(), "123 4.5 hello world!");
546 | }
547 | 
548 | BOOST_AUTO_TEST_CASE(adjacent_map) {
549 | 	std::string s;
550 | 	adjacent_printer printer{s};
551 | 	vta::adjacent_map<2>(std::ref(printer))(1, 2, 3, 4, 5, 6);
552 | 	BOOST_CHECK_EQUAL(s, "26122030");
553 | }
554 | 
555 | BOOST_AUTO_TEST_CASE(foldl) {
556 | 	auto s = string_concat{};
557 | 	auto const result = vta::foldl(s)(1, 2, 3);
558 | 	BOOST_CHECK_EQUAL(result, "123");
559 | }
560 | 
561 | BOOST_AUTO_TEST_CASE(foldr) {
562 | 	auto minus = [](auto l, auto r){ return l - r; };
563 | 	BOOST_CHECK_EQUAL(vta::foldr(minus)(1), 1);
564 | 	BOOST_CHECK_EQUAL(vta::foldr(minus)(1, 2), -1);
565 | 	BOOST_CHECK_EQUAL(vta::foldr(minus)(1, 2, 3), 2);
566 | }
567 | 
568 | BOOST_AUTO_TEST_CASE(compose) {
569 | 	{
570 | 		std::stringstream ss;
571 | 		vta::forward_after<vta::compose<vta::left_shift<1>>>(vta::map(printer{ss}))(0, 1, 2, 3, 4);
572 | 		BOOST_CHECK_EQUAL(ss.str(), "12340");
573 | 	}
574 | 
575 | 	{
576 | 		std::stringstream ss;
577 | 		vta::forward_after<vta::compose<vta::left_shift<1>, vta::flip>>(vta::map(printer{ss}))(0, 1, 2, 3, 4);
578 | 		BOOST_CHECK_EQUAL(ss.str(), "21340");
579 | 	}
580 | }
581 | 
582 | BOOST_AUTO_TEST_CASE(swap) {
583 | 	{
584 | 		std::stringstream ss;
585 | 		vta::forward_after<vta::swap<2, 4>>(vta::map(printer{ss}))(0, 1, 2, 3, 4);
586 | 		BOOST_CHECK_EQUAL(ss.str(), "01432");
587 | 	}
588 | 
589 | 	{
590 | 		std::stringstream ss;
591 | 		vta::forward_after<vta::swap<2, -1>>(vta::map(printer{ss}))(0, 1, 2, 3, 4);
592 | 		BOOST_CHECK_EQUAL(ss.str(), "01432");
593 | 	}
594 | 
595 | 	{
596 | 		std::stringstream ss;
597 | 		vta::forward_after<vta::swap<0, 2>>(vta::map(printer{ss}))(0, 1, 2, 3, 4);
598 | 		BOOST_CHECK_EQUAL(ss.str(), "21034");
599 | 	}
600 | 
601 | 	{
602 | 		std::stringstream ss;
603 | 		vta::forward_after<vta::swap<1, 1>>(vta::map(printer{ss}))(0, 1, 2, 3, 4);
604 | 		BOOST_CHECK_EQUAL(ss.str(), "01234");
605 | 	}
606 | 
607 | 	{
608 | 		std::stringstream ss;
609 | 		vta::forward_after<vta::swap<2, -3>>(vta::map(printer{ss}))(0, 1, 2, 3, 4);
610 | 		BOOST_CHECK_EQUAL(ss.str(), "01234");
611 | 	}
612 | }
613 | 
614 | BOOST_AUTO_TEST_CASE(all_of) {
615 | 	auto const all_positive_int = vta::all_of(is_positive_int{});
616 | 	BOOST_CHECK_EQUAL(all_positive_int(1, 2), true);
617 | 	BOOST_CHECK_EQUAL(all_positive_int("hello", 2), false);
618 | 	BOOST_CHECK_EQUAL(all_positive_int(0u, 2), false);
619 | 	BOOST_CHECK_EQUAL(all_positive_int(-2), false);
620 | 	BOOST_CHECK_EQUAL(all_positive_int(), true);
621 | 
622 | 	BOOST_CHECK_EQUAL(vta::all_of(&is_true)(), true);
623 | 	BOOST_CHECK_EQUAL(vta::all_of(&is_true)(true), true);
624 | 	BOOST_CHECK_EQUAL(vta::all_of(&is_true)(false), false);
625 | 	BOOST_CHECK_EQUAL(vta::all_of(&is_true)(true, false), false);
626 | }
627 | 
628 | BOOST_AUTO_TEST_CASE(any_of) {
629 | 	BOOST_CHECK_EQUAL(vta::any_of(is_positive_int{})(1, 2), true);
630 | 	BOOST_CHECK_EQUAL(vta::any_of(is_positive_int{})("hello", 2), true);
631 | 	BOOST_CHECK_EQUAL(vta::any_of(is_positive_int{})(0u, 2), true);
632 | 	BOOST_CHECK_EQUAL(vta::any_of(is_positive_int{})(-2), false);
633 | 	BOOST_CHECK_EQUAL(vta::any_of(is_positive_int{})(), false);
634 | }
635 | 
636 | BOOST_AUTO_TEST_CASE(none_of) {
637 | 	BOOST_CHECK_EQUAL(vta::none_of(is_positive_int{})(1, 2), false);
638 | 	BOOST_CHECK_EQUAL(vta::none_of(is_positive_int{})("hello", 2), false);
639 | 	BOOST_CHECK_EQUAL(vta::none_of(is_positive_int{})(0u, 2), false);
640 | 	BOOST_CHECK_EQUAL(vta::none_of(is_positive_int{})(-2), true);
641 | 	BOOST_CHECK_EQUAL(vta::none_of(is_positive_int{})(), true);
642 | }
643 | 
644 | BOOST_AUTO_TEST_CASE(macro) {
645 | 	BOOST_CHECK_EQUAL(vta::foldl(VTA_FN_TO_FUNCTOR(std::max))(0, 1, 4, 2), 4);
646 | }
647 | 
648 | BOOST_AUTO_TEST_SUITE_END()
649 | 


--------------------------------------------------------------------------------
/tests/main.cpp:
--------------------------------------------------------------------------------
1 | #define BOOST_TEST_MODULE "VariadicTemplateAlgorithms Tests"
2 | #include <boost/test/unit_test.hpp>
3 | 


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