combinations_with_replacement({1, 2}, 4):
{ 4 0 }
{ 3 1 }
{ 2 2 }
{ 1 3 }
{ 0 4 }

auto r = iter::range(5);
auto first = r.begin();

std::string s = "abc";
auto p = iter::product(s,s);
auto first = p.begin();

System:
$  uname -a
Darwin JiriMBP.home 14.4.0 Darwin Kernel Version 14.4.0: Thu May 28 11:35:04 PDT 2015; root:xnu-2782.30.5~1/RELEASE_X86_64 x86_64 i386 MacBookPro11,2 Darwin
$  g++ --version
Configured with: --prefix=/Applications/Xcode.app/Contents/Developer/usr --with-gxx-include-dir=/usr/include/c++/4.2.1
Apple LLVM version 6.1.0 (clang-602.0.53) (based on LLVM 3.6.0svn)
Target: x86_64-apple-darwin14.4.0
Thread model: posix

c++ -o test_combinations.o -c -g -Wall -Wextra -std=c++11 -fdiagnostics-color=always -I/usr/local/include -I. -I/Users/Jiri/Documents/lib/cpp/iter/cppitertools test_combinations.cpp
In file included from test_combinations.cpp:1:
In file included from ./helpers.hpp:4:
In file included from /Users/Jiri/Documents/lib/cpp/iter/cppitertools/iterbase.hpp:13:
In file included from /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../include/c++/v1/functional:477:
/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../include/c++/v1/memory:1645:31: error: no matching constructor for
      initialization of 'std::__1::vector<char, std::__1::allocator<char> >'
            ::new((void*)__p) _Up(_VSTD::forward<_Args>(__args)...);
                              ^   ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../include/c++/v1/memory:1572:18: note: in instantiation of function
      template specialization 'std::__1::allocator<std::__1::vector<char, std::__1::allocator<char> > >::construct<std::__1::vector<char,
      std::__1::allocator<char> >, iter::IteratorIterator<std::__1::__wrap_iter<std::__1::__wrap_iter<char *> *>, long>,
      iter::IteratorIterator<std::__1::__wrap_iter<std::__1::__wrap_iter<char *> *>, long> >' requested here
            {__a.construct(__p, _VSTD::forward<_Args>(__args)...);}
                 ^
/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../include/c++/v1/memory:1453:14: note: in instantiation of function
      template specialization 'std::__1::allocator_traits<std::__1::allocator<std::__1::vector<char, std::__1::allocator<char> > >
      >::__construct<std::__1::vector<char, std::__1::allocator<char> >, iter::IteratorIterator<std::__1::__wrap_iter<std::__1::__wrap_iter<char *> *>, long>,
      iter::IteratorIterator<std::__1::__wrap_iter<std::__1::__wrap_iter<char *> *>, long> >' requested here
            {__construct(__has_construct<allocator_type, pointer, _Args...>(),
             ^
/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../include/c++/v1/vector:1633:25: note: in instantiation of function
      template specialization 'std::__1::allocator_traits<std::__1::allocator<std::__1::vector<char, std::__1::allocator<char> > >
      >::construct<std::__1::vector<char, std::__1::allocator<char> >, iter::IteratorIterator<std::__1::__wrap_iter<std::__1::__wrap_iter<char *> *>, long>,
      iter::IteratorIterator<std::__1::__wrap_iter<std::__1::__wrap_iter<char *> *>, long> >' requested here
        __alloc_traits::construct(this->__alloc(),
                        ^
test_combinations.cpp:21:12: note: in instantiation of function template specialization 'std::__1::vector<std::__1::vector<char, std::__1::allocator<char> >,
      std::__1::allocator<std::__1::vector<char, std::__1::allocator<char> > >
      >::emplace_back<iter::IteratorIterator<std::__1::__wrap_iter<std::__1::__wrap_iter<char *> *>, long>,
      iter::IteratorIterator<std::__1::__wrap_iter<std::__1::__wrap_iter<char *> *>, long> >' requested here
        sc.emplace_back(std::begin(v), std::end(v));
           ^
/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../include/c++/v1/vector:521:5: note: candidate constructor not viable:
      no known conversion from 'iter::IteratorIterator<std::__1::__wrap_iter<std::__1::__wrap_iter<char *> *>, long>' to 'size_type' (aka 'unsigned long') for
      1st argument
    vector(size_type __n, const_reference __x);
    ^
/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../include/c++/v1/vector:555:5: note: candidate constructor not viable:
      no known conversion from 'iter::IteratorIterator<std::__1::__wrap_iter<std::__1::__wrap_iter<char *> *>, long>' to 'initializer_list<value_type>' for 1st
      argument
    vector(initializer_list<value_type> __il, const allocator_type& __a);
    ^
/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../include/c++/v1/vector:566:5: note: candidate constructor not viable:
      no known conversion from 'iter::IteratorIterator<std::__1::__wrap_iter<std::__1::__wrap_iter<char *> *>, long>' to 'const std::__1::vector<char,
      std::__1::allocator<char> >' for 1st argument
    vector(const vector& __x, const allocator_type& __a);
    ^
/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../include/c++/v1/vector:574:5: note: candidate constructor not viable:
      no known conversion from 'iter::IteratorIterator<std::__1::__wrap_iter<std::__1::__wrap_iter<char *> *>, long>' to
      'std::__1::vector<char, std::__1::allocator<char> >' for 1st argument
    vector(vector&& __x, const allocator_type& __a);
    ^
/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../include/c++/v1/vector:525:35: note: candidate template ignored:
      disabled by 'enable_if' [with _InputIterator = iter::IteratorIterator<std::__1::__wrap_iter<std::__1::__wrap_iter<char *> *>, long>]
               typename enable_if<__is_input_iterator  <_InputIterator>::value &&
                                  ^
/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../include/c++/v1/vector:540:35: note: candidate template ignored:
      disabled by 'enable_if' [with _ForwardIterator = iter::IteratorIterator<std::__1::__wrap_iter<std::__1::__wrap_iter<char *> *>, long>]
               typename enable_if<__is_forward_iterator<_ForwardIterator>::value &&
                                  ^
/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../include/c++/v1/vector:532:9: note: candidate constructor template not
      viable: requires at least 3 arguments, but 2 were provided
        vector(_InputIterator __first, _InputIterator __last, const allocator_type& __a,
        ^
/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../include/c++/v1/vector:546:9: note: candidate constructor template not
      viable: requires at least 3 arguments, but 2 were provided
        vector(_ForwardIterator __first, _ForwardIterator __last, const allocator_type& __a,
        ^
/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../include/c++/v1/vector:510:40: note: candidate constructor not viable:
      requires single argument '__a', but 2 arguments were provided
    _LIBCPP_INLINE_VISIBILITY explicit vector(const allocator_type& __a)
                                       ^
/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../include/c++/v1/vector:517:14: note: candidate constructor not viable:
      requires single argument '__n', but 2 arguments were provided
    explicit vector(size_type __n);
             ^
/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../include/c++/v1/vector:553:5: note: candidate constructor not viable:
      requires single argument '__il', but 2 arguments were provided
    vector(initializer_list<value_type> __il);
    ^
/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../include/c++/v1/vector:565:5: note: candidate constructor not viable:
      requires single argument '__x', but 2 arguments were provided
    vector(const vector& __x);
    ^
/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../include/c++/v1/vector:571:5: note: candidate constructor not viable:
      requires single argument '__x', but 2 arguments were provided
    vector(vector&& __x)
    ^
/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../include/c++/v1/vector:522:5: note: candidate constructor not viable:
      requires 3 arguments, but 2 were provided
    vector(size_type __n, const_reference __x, const allocator_type& __a);
    ^
/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../include/c++/v1/vector:503:5: note: candidate constructor not viable:
      requires 0 arguments, but 2 were provided
    vector()
    ^
1 error generated.
scons: *** [test_combinations.o] Error 1
scons: building terminated because of errors.

iterbase.hpp(94,36): error C2672:  'iter::impl::get_iters::get_begin': no matching overloaded function found
iterbase.hpp(94,1): error C2893:  Failed to specialize function template 'unknown-type iter::impl::get_iters::get_begin(T &)'
iterbase.hpp(104,43): error C2672:  'std::declval': no matching overloaded function found
iterbase.hpp(104,1): error C2893:  Failed to specialize function template '_Add_reference<_Ty,void>::_Rvalue std::declval(void) noexcept'

struct A {
    int key1;
    int key2;
    int x;
    int y;
    int value;
};

void func() {
    using namespace std;

    // inputs
    std::vector<int> uniquex{ 1, 2 };
    std::vector<int> uniquey{ 1, 2 };
    vector<A> vec{
        { 10, 9, 1, 1, 5 },     { 10, 9, 1, 2, 6 },     
        { 10, 10, 1, 1, 1 },    { 10, 10, 1, 2, 2 },
        { 10, 9, 2, 1, 7 },     { 10, 9, 2, 2, 8 },
        { 10, 10, 2, 1, 3 },    { 10, 10, 2, 2, 4 },
    };
    auto keyFunc = [](const A& a) { return make_tuple(a.key1, a.key2); };

    for (auto&& gb : iter::groupby(vec, keyFunc)) {
        std::cout << "key(" << std::get<0>(gb.first) << "," << std::get<1>(gb.first) << "): ";
                for (auto&& s : gb.second) {
                        std::cout << s.value << "  ";
                }
                std::cout << '\n';
        }

error: no member named 'rbegin' in 'boost::integer_range<int>'
        decltype(std::declval<Container&>().rbegin());

using T = unsigned short;
    for(auto i : iter::count(T{})) {
        if(cond)
            break;
    }

  vector<bool> v{true, true, false, false,false, true, true};
  for (auto &&x: iter::groupby(v,[](auto b){return b;})) {
    cout << "group: ";
    for (auto &&g: x.second)
      cout << g << " ";
    cout << endl;
  }

prints

group: 1 1 0 0 0 1 1 

  vector<int> v{5,5,5,3,3};
  for (auto &&x: iter::groupby(v,[](auto b){return b;})) {
    cout << "group: ";
    for (auto &&g: x.second)
      cout << g << " ";
    cout << endl;
  }

prints

group: 5 5 5 
group: 3 3

#include <iostream>
#include <vector>
#include <itertools/product.hpp>

struct MoveOnlyType {
    MoveOnlyType() = default;
    MoveOnlyType(MoveOnlyType const& other) = delete;
    MoveOnlyType(MoveOnlyType&& other) = default;
    MoveOnlyType& operator=(MoveOnlyType const& other) = delete;
    MoveOnlyType& operator=(MoveOnlyType&& other) = default;
};

int main() {

    std::vector<MoveOnlyType> v1, v2;
    v1.push_back(MoveOnlyType());
    v1.push_back(MoveOnlyType());

    v2.push_back(MoveOnlyType());
    v2.push_back(MoveOnlyType());
    v2.push_back(MoveOnlyType());


    for (auto&& pair_of_moveonly: iter::product(v1, v2)) 
        std::cout << "it does not work" << std::endl;
}

note: copy assignment operator of 'Iterator' is implicitly deleted because field 'step' is of const-qualified type 'const int'
                    const T step;

Severity  Code  Description  Project  File  Line  Suppression State
Error  C2133  ' ?? ?? :: ?? ::derefers': unknown size  ...\include\cppitertools\chain.hpp  72

import itertools as it

class MyItem:
    def __init__(self, val):
        self.val = val
    def with_val(self, val):
        self.val = val
        return self

if "__main__" == __name__:
    vec = [MyItem(41), MyItem(42), MyItem(43)]
    transformed1 = it.imap(lambda el: el.with_val(el.val + 10), vec)
    filtered = it.ifilter(lambda el: 52 != el.val, transformed1)
    transformed2 = it.imap(lambda el: el.with_val(el.val - 10), filtered)

    for el in transformed2:
        print(el.val)

#include <iostream>
#include <vector>

#include "imap.hpp"
#include "filter.hpp"

class MyMoveOnly {
    int val;
public:
    MyMoveOnly() { };
    MyMoveOnly(int val) : val(val) { }
    MyMoveOnly(const MyMoveOnly&) = delete;
    MyMoveOnly& operator=(const MyMoveOnly&) = delete;
    MyMoveOnly(MyMoveOnly&& other) : val(other.val) { }
    MyMoveOnly& operator=(MyMoveOnly&& other) {
        this->val = other.val;
        return *this;
    }
    int get_val() {
        return val;
    }
    void set_val(int val) {
        this->val = val;        
    }
};

namespace it = iter;

int main() {
    // source data
    std::vector<MyMoveOnly> vec{};
    vec.emplace_back(MyMoveOnly(41));
    vec.emplace_back(MyMoveOnly(42));
    vec.emplace_back(MyMoveOnly(43));
    // some transformations
    auto transformed1 = it::imap([](MyMoveOnly& el) {
        int va = el.get_val();
        el.set_val(va + 10);
        return std::move(el);
    }, vec);
    // r-value ref is used here because l-value ref won't compile
    auto filtered = it::filter([](MyMoveOnly&& el) {
        return 52 != el.get_val();
    }, transformed1);
    auto transformed2 = it::imap([](MyMoveOnly& el) {
        int va = el.get_val();
        el.set_val(va - 10);
        return std::move(el);
    }, filtered);
    // print data
    for (auto&& el : transformed2) {
        std::cout << el.get_val() << std::endl;
    }

    return 0;
}

error: indirection requires pointer operand ('const iterator_type<iter::Productor<iter::Range<int>, iter::Range<int> > &>' (aka 'const iter::Productor<iter::Range<int>, iter::Range<int> >::Iterator') invalid)
                        return *this->sub_iter;

vector<int16_t> v(10000, 0);
  auto a = iter::chunked(v,480);
  auto b = iter::filter([](auto & chunk){ return true;}, a);
  auto c = iter::imap([](auto & chunk){ cout << chunk.size() << " "; return 1;}, b);
  for(auto &&x: c);

std::vector<int> v = {1, 2, 3, 4, 5, 6, 7, 8};

auto f = iter::enumerate(v) | iter::filter([](auto& i) { return std::get<1>(i) > 4; });

for (auto&& [i, e]: f) {
    std::cout << i << ", " << e << '\n';
}

error: use of deleted function ‘std::optional<iter::impl::EnumIterYield<long unsigned int, int&> >& std::optional<iter::impl::EnumIterYield<long unsigned int, int&> >::operator=(std::optional<iter::impl::EnumIterYield<long unsigned int, int&> >&&)’

#include <stdlib.h>
#include "cppitertools/chain.hpp"

std::vector<const char *> c1 = {"a", "b", "c"};
std::set<const char *> c2 = {"d", "d", "e"};
for (auto n : iter::chain(c1, c2))
{
    std::cout << n << std::endl;
}

in instantiation of function template specialization 'iter::impl::ChainMaker::operator()<std::vector<const char *,
      std::allocator<const char *> > &, std::set<const char *, std::less<const char *>, std::allocator<const char *> >
      &>' requested here
for (auto n : iter::chain(c1, c2)) {std::cout << n << std::endl;}
                         ^

auto fn = []{};
using MapType = decltype(iter::imap(fn, 1));

  std::vector<int> v{true,true,true,false,false,true,true};
  auto a = iter::groupby(v,[](bool b){return b;});
  auto b = iter::filter([](auto &g){ return g.first;},a);
  auto c = iter::imap([](auto &g){ return std::distance(g.second.begin(), g.second.end()); }, b);
  for (size_t x: c)
    std::cout << x;

Program received signal SIGSEGV, Segmentation fault.
0x00005555556117b1 in __gnu_cxx::operator!=<int*, std::vector<int, std::allocator<int> > > (__lhs=<error reading variable: Cannot access memory at address 0x0>, __rhs=<error reading variable: Cannot access memory at address 0x8>) at /usr/include/c++/8/bits/stl_iterator.h:887
887	    { return __lhs.base() != __rhs.base(); }

#0  0x00005555556117b1 in __gnu_cxx::operator!=<int*, std::vector<int, std::allocator<int> > > (__lhs=<error reading variable: Cannot access memory at address 0x0>, __rhs=<error reading variable: Cannot access memory at address 0x8>) at /usr/include/c++/8/bits/stl_iterator.h:887
#1  0x00005555555e99e2 in iter::impl::GroupProducer<std::vector<int, std::allocator<int> >&, main(int, char**)::<lambda(bool)> >::Iterator<std::vector<int, std::allocator<int> >&>::increment_iterator(void) (this=0x0) at /home/miguel/Development/IPL/investigacao/vad_check/cppitertools/groupby.hpp:148
#2  0x00005555555e951b in iter::impl::GroupProducer<std::vector<int, std::allocator<int> >&, main(int, char**)::<lambda(bool)> >::Group<std::vector<int, std::allocator<int> >&>::GroupIterator::operator++(void) (this=0x7fffffffc520) at /home/miguel/Development/IPL/investigacao/vad_check/cppitertools/groupby.hpp:247
#3  0x00005555555e9088 in std::__distance<iter::impl::GroupProducer<std::vector<int>&, main(int, char**)::<lambda(bool)> >::Group<std::vector<int>&>::GroupIterator>(iter::impl::GroupProducer<std::vector<int, std::allocator<int> >&, main(int, char**)::<lambda(bool)> >::Group<std::vector<int, std::allocator<int> >&>::GroupIterator, iter::impl::GroupProducer<std::vector<int, std::allocator<int> >&, main(int, char**)::<lambda(bool)> >::Group<std::vector<int, std::allocator<int> >&>::GroupIterator, std::input_iterator_tag) (__first=..., __last=...) at /usr/include/c++/8/bits/stl_iterator_base_funcs.h:89
#4  0x00005555555e8843 in std::distance<iter::impl::GroupProducer<std::vector<int>&, main(int, char**)::<lambda(bool)> >::Group<std::vector<int>&>::GroupIterator>(iter::impl::GroupProducer<std::vector<int, std::allocator<int> >&, main(int, char**)::<lambda(bool)> >::Group<std::vector<int, std::allocator<int> >&>::GroupIterator, iter::impl::GroupProducer<std::vector<int, std::allocator<int> >&, main(int, char**)::<lambda(bool)> >::Group<std::vector<int, std::allocator<int> >&>::GroupIterator) (__first=..., __last=...) at /usr/include/c++/8/bits/stl_iterator_base_funcs.h:141
#5  0x00005555555e6d10 in <lambda(auto:5&)>::operator()<std::pair<bool, iter::impl::GroupProducer<std::vector<int>&, main(int, char**)::<lambda(bool)> >::Group<std::vector<int>&> > >(std::pair<bool, iter::impl::GroupProducer<std::vector<int>&, main(int, char**)::<lambda(bool)> >::Group<std::vector<int, std::allocator<int> >&> > &) const (__closure=0x7fffffffc870, g={...}) at /home/miguel/Development/IPL/investigacao/vad_check/src/main.cc:456
#6  0x00005555555e90cc in std::__invoke_impl<long int, main(int, char**)::<lambda(auto:5&)>&, std::pair<bool, iter::impl::GroupProducer<std::vector<int>&, main(int, char**)::<lambda(bool)> >::Group<std::vector<int, std::allocator<int> >&> >&>(std::__invoke_other, <lambda(auto:5&)> &, std::pair<bool, iter::impl::GroupProducer<std::vector<int>&, main(int, char**)::<lambda(bool)> >::Group<std::vector<int, std::allocator<int> >&> > &) (__f=..., __args#0={...}) at /usr/include/c++/8/bits/invoke.h:60
#7  0x00005555555e887c in std::__invoke<main(int, char**)::<lambda(auto:5&)>&, std::pair<bool, iter::impl::GroupProducer<std::vector<int>&, main(int, char**)::<lambda(bool)> >::Group<std::vector<int, std::allocator<int> >&> >&>(<lambda(auto:5&)> &, std::pair<bool, iter::impl::GroupProducer<std::vector<int>&, main(int, char**)::<lambda(bool)> >::Group<std::vector<int, std::allocator<int> >&> > &) (__fn=..., __args#0={...}) at /usr/include/c++/8/bits/invoke.h:95
#8  0x00005555555e6d5a in std::__apply_impl<main(int, char**)::<lambda(auto:5&)>&, std::tuple<std::pair<bool, iter::impl::GroupProducer<std::vector<int>&, main(int, char**)::<lambda(bool)> >::Group<std::vector<int, std::allocator<int> >&> >&>, 0>(<lambda(auto:5&)> &, std::tuple<std::pair<bool, iter::impl::GroupProducer<std::vector<int>&, main(int, char**)::<lambda(bool)> >::Group<std::vector<int, std::allocator<int> >&> >&> &&, std::index_sequence) (__f=..., __t=...) at /usr/include/c++/8/tuple:1678
#9  0x00005555555e6d98 in std::apply<main(int, char**)::<lambda(auto:5&)>&, std::tuple<std::pair<bool, iter::impl::GroupProducer<std::vector<int>&, main(int, char**)::<lambda(bool)> >::Group<std::vector<int, std::allocator<int> >&> >&> >(<lambda(auto:5&)> &, std::tuple<std::pair<bool, iter::impl::GroupProducer<std::vector<int>&, main(int, char**)::<lambda(bool)> >::Group<std::vector<int, std::allocator<int> >&> >&> &&) (__f=..., __t=...) at /usr/include/c++/8/tuple:1687
#10 0x00005555555e6e6b in iter::impl::StarMapper<main(int, char**)::<lambda(auto:5&)>, iter::impl::Zipped<std::tuple<iter::impl::Filtered<main(int, char**)::<lambda(auto:4&)>, iter::impl::GroupProducer<std::vector<int, std::allocator<int> >&, main(int, char**)::<lambda(bool)> >&>&>, 0> >::Iterator<iter::impl::Zipped<std::tuple<iter::impl::Filtered<main(int, char**)::<lambda(auto:4&)>, iter::impl::GroupProducer<std::vector<int, std::allocator<int> >&, main(int, char**)::<lambda(bool)> >&>&>, 0> >::operator*(void) (this=0x7fffffffc6f0) at /home/miguel/Development/IPL/investigacao/vad_check/cppitertools/starmap.hpp:86
#11 0x00005555555e7998 in main (argc=3, argv=0x7fffffffd948) at /home/miguel/Development/IPL/investigacao/vad_check/src/main.cc:458

Prelude Data.List> x = [True,True,True,False,False,True]
Prelude Data.List> group x
[[True,True,True],[False,False],[True]]
Prelude Data.List> fmap length $ filter (!!0) $ group x
[3,1]
Prelude Data.List> sortDesc = sortBy (flip compare)
Prelude Data.List> head $ sortDesc $ fmap length $ filter (!!0) $ group x
3

CMake Error at C:/Program Files (x86)/CMake/share/cmake-3.15/Modules/FindPackageHandleStandardArgs.cmake:137 (message):
  Could NOT find Boost (missing: Boost_INCLUDE_DIR) (Required is at least
  version "1.60.0")
Call Stack (most recent call first):
  C:/Program Files (x86)/CMake/share/cmake-3.15/Modules/FindPackageHandleStandardArgs.cmake:378 (_FPHSA_FAILURE_MESSAGE)
  C:/Program Files (x86)/CMake/share/cmake-3.15/Modules/FindBoost.cmake:2161 (find_package_handle_standard_args)
  CMakeLists.txt:12 (find_package)

  std::vector<int> ns(3, 9);
  for (auto&& n : sorted(ns)) {
    n = -1;
  }
  Vec vc(3, -1);
  REQUIRE(ns == vc);

typedef decltype(std::begin(std::declval<Iterable&>())) iterator_type;